123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276
import { matches } from "../dependencies.ts";import { ConfigSpec, ValueSpecAny } from "../types.ts";
type TypeBoolean = "boolean";type TypeString = "string";type TypeNumber = "number";type TypeObject = "object";type TypeList = "list";type TypeEnum = "enum";type TypePointer = "pointer";type TypeUnion = "union";
// prettier-ignore// deno-fmt-ignoretype GuardDefaultNullable<A, Type> =     A extends { readonly default: unknown} ? Type :    A extends { readonly nullable: true} ? Type :    A extends {readonly  nullable: false} ? Type | null | undefined :    Type
// prettier-ignore// deno-fmt-ignoretype GuardNumber<A> =     A extends {readonly type:TypeNumber} ? GuardDefaultNullable<A, number> :    unknown// prettier-ignore// deno-fmt-ignoretype GuardString<A> =     A extends {readonly type:TypeString} ? GuardDefaultNullable<A, string> :    unknown
// prettier-ignore// deno-fmt-ignoretype GuardBoolean<A> =     A extends {readonly type:TypeBoolean} ? GuardDefaultNullable<A, boolean> :        unknown
// prettier-ignore// deno-fmt-ignoretype GuardObject<A> =     A extends {readonly type: TypeObject, readonly spec: infer B} ? (        B extends Record<string, unknown> ? {readonly [K in keyof B & string]: _<GuardAll<B[K]>>} :        {_error: "Invalid Spec"}    ) :    unknown
// prettier-ignore// deno-fmt-ignoreexport type GuardList<A> =     A extends {readonly type:TypeList, readonly subtype: infer B, spec?: {spec?: infer C }} ? ReadonlyArray<GuardAll<Omit<A, "type" | "spec"> & ({type: B, spec: C})>> :    // deno-lint-ignore ban-types    A extends {readonly type:TypeList, readonly subtype: infer B, spec?: {}} ? ReadonlyArray<GuardAll<Omit<A, "type" > & ({type: B})>> :    unknown// prettier-ignore// deno-fmt-ignoretype GuardPointer<A> =     A extends {readonly type:TypePointer} ? {_UNKNOWN: "Pointer"} :    unknown// prettier-ignore// deno-fmt-ignoretype GuardEnum<A> =     A extends {readonly type:TypeEnum, readonly values: ArrayLike<infer B>} ? GuardDefaultNullable<A, B> :    unknown// prettier-ignore// deno-fmt-ignoretype GuardUnion<A> =     A extends {readonly type:TypeUnion, readonly tag: {id: infer Id & string}, variants: infer Variants & Record<string, unknown>} ? {[K in keyof Variants]: {[keyType in Id & string]: K}&TypeFromProps<Variants[K]>}[keyof Variants] :    unknown
type _<T> = T;export type GuardAll<A> = GuardNumber<A> &  GuardString<A> &  GuardBoolean<A> &  GuardObject<A> &  GuardList<A> &  GuardPointer<A> &  GuardUnion<A> &  GuardEnum<A>;// prettier-ignore// deno-fmt-ignoreexport type TypeFromProps<A> =  A extends Record<string, unknown> ? {readonly [K in keyof A & string]: _<GuardAll<A[K]>>} : unknown;
const isType = matches.shape({ type: matches.string });const recordString = matches.dictionary([matches.string, matches.unknown]);const matchDefault = matches.shape({ default: matches.unknown });const matchNullable = matches.shape({ nullable: matches.literal(true) });const matchPattern = matches.shape({ pattern: matches.string });const rangeRegex = /(\[|\()(\*|(\d|\.)+),(\*|(\d|\.)+)(\]|\))/;const matchRange = matches.shape({ range: matches.regex(rangeRegex) });const matchIntegral = matches.shape({ integral: matches.literal(true) });const matchSpec = matches.shape({ spec: recordString });const matchSubType = matches.shape({ subtype: matches.string });const matchUnion = matches.shape({  tag: matches.shape({ id: matches.string }),  variants: recordString,});const matchValues = matches.shape({  values: matches.arrayOf(matches.string),});
function charRange(value = "") {  const split = value    .split("-")    .filter(Boolean)    .map((x) => x.charCodeAt(0));  if (split.length < 1) return null;  if (split.length === 1) return [split[0], split[0]];  return [split[0], split[1]];}
/** * * @param generate.charset Pattern like "a-z" or "a-z,1-5" * @param generate.len Length to make random variable * @param param1 * @returns */export function generateDefault(generate: { charset: string; len: number }, { random = () => Math.random() } = {}) {  const validCharSets: number[][] = generate.charset.split(",").map(charRange).filter(Array.isArray);  if (validCharSets.length === 0) throw new Error("Expecing that we have a valid charset");  const max = validCharSets.reduce((acc, x) => x.reduce((x, y) => Math.max(x, y), acc), 0);  let i = 0;  const answer: string[] = Array(generate.len);  while (i < generate.len) {    const nextValue = Math.round(random() * max);    const inRange = validCharSets.reduce(      (acc, [lower, upper]) => acc || (nextValue >= lower && nextValue <= upper),      false    );    if (!inRange) continue;    answer[i] = String.fromCharCode(nextValue);    i++;  }  return answer.join("");}
function withPattern<A>(value: unknown) {  if (matchPattern.test(value)) return matches.regex(RegExp(value.pattern));  return matches.string;}export function matchNumberWithRange(range: string) {  const matched = rangeRegex.exec(range);  if (!matched) return matches.number;  const [, left, leftValue, , rightValue, , right] = matched;  return matches.number    .validate(      leftValue === "*" ? (_) => true : left === "[" ? (x) => x >= Number(leftValue) : (x) => x > Number(leftValue),      leftValue === "*" ? "any" : left === "[" ? `greaterThanOrEqualTo${leftValue}` : `greaterThan${leftValue}`    )    .validate(      rightValue === "*" ? (_) => true : right === "]" ? (x) => x <= Number(rightValue) : (x) => x < Number(rightValue),      rightValue === "*" ? "any" : right === "]" ? `lessThanOrEqualTo${rightValue}` : `lessThan${rightValue}`    );}function withIntegral(parser: matches.Parser<unknown, number>, value: unknown) {  if (matchIntegral.test(value)) {    return parser.validate(Number.isInteger, "isIntegral");  }  return parser;}function withRange(value: unknown) {  if (matchRange.test(value)) {    return matchNumberWithRange(value.range);  }  return matches.number;}const isGenerator = matches.shape({ charset: matches.string, len: matches.number }).test;function defaultNullable<A>(parser: matches.Parser<unknown, A>, value: unknown) {  if (matchDefault.test(value)) {    if (isGenerator(value.default)) return parser.defaultTo(parser.unsafeCast(generateDefault(value.default)));    return parser.defaultTo(value.default);  }  if (matchNullable.test(value)) return parser.optional();  return parser;}
/** * ConfigSpec: Tells the UI how to ask for information, verification, and will send the service a config in a shape via the spec. * ValueSpecAny: This is any of the values in a config spec. * * Use this when we want to convert a value spec any into a parser for what a config will look like * @param value * @returns */export function guardAll<A extends ValueSpecAny>(value: A): matches.Parser<unknown, GuardAll<A>> {  if (!isType.test(value)) {    // deno-lint-ignore no-explicit-any    return matches.unknown as any;  }  switch (value.type) {    case "boolean":      // deno-lint-ignore no-explicit-any      return defaultNullable(matches.boolean, value) as any;
    case "string":      // deno-lint-ignore no-explicit-any      return defaultNullable(withPattern(value), value) as any;
    case "number":      return defaultNullable(        withIntegral(withRange(value), value),        value        // deno-lint-ignore no-explicit-any      ) as any;
    case "object":      if (matchSpec.test(value)) {        // deno-lint-ignore no-explicit-any        return defaultNullable(typeFromProps(value.spec), value) as any;      }      // deno-lint-ignore no-explicit-any      return matches.unknown as any;
    case "list": {      const spec = (matchSpec.test(value) && value.spec) || {};      const rangeValidate = (matchRange.test(value) && matchNumberWithRange(value.range).test) || (() => true);
      const { ...arrayOfSpec } = spec;
      const subtype = matchSubType.unsafeCast(value).subtype;      return defaultNullable(        matches          // deno-lint-ignore no-explicit-any          .arrayOf(guardAll({ type: subtype, ...arrayOfSpec } as any))          .validate((x) => rangeValidate(x.length), "valid length"),        value        // deno-lint-ignore no-explicit-any      ) as any;    }    case "enum":      if (matchValues.test(value)) {        return defaultNullable(          matches.literals(value.values[0], ...value.values),          value          // deno-lint-ignore no-explicit-any        ) as any;      }      // deno-lint-ignore no-explicit-any      return matches.unknown as any;    case "pointer":      // deno-lint-ignore no-explicit-any      return matches.unknown as any;    case "union":      if (matchUnion.test(value)) {        return matches.some(          ...Object.entries(value.variants).map(([variant, spec]) =>            matches.shape({ [value.tag.id]: matches.literal(variant) }).concat(typeFromProps(spec))          ) // deno-lint-ignore no-explicit-any        ) as any;      }      // deno-lint-ignore no-explicit-any      return matches.unknown as any;  }
  // deno-lint-ignore no-explicit-any  return matches.unknown as any;}/** * ConfigSpec: Tells the UI how to ask for information, verification, and will send the service a config in a shape via the spec. * ValueSpecAny: This is any of the values in a config spec. * * Use this when we want to convert a config spec into a parser for what a config will look like * @param valueDictionary * @returns */export function typeFromProps<A extends ConfigSpec>(valueDictionary: A): matches.Parser<unknown, TypeFromProps<A>> {  // deno-lint-ignore no-explicit-any  if (!recordString.test(valueDictionary)) return matches.unknown as any;  return matches.shape(    Object.fromEntries(Object.entries(valueDictionary).map(([key, value]) => [key, guardAll(value)]))    // deno-lint-ignore no-explicit-any  ) as any;}