From c47fc98620a18a64559fe9fcfade58e168533cbb Mon Sep 17 00:00:00 2001
From: BluJ <mogulslayer@gmail.com>
Date: Tue, 14 Feb 2023 10:22:08 -0700
Subject: [PATCH] chore: Update something

---
 config/v2_spec.ts     | 616 ------------------------------------------
 config/value.ts       |  17 +-
 types/config-types.ts |   1 +
 3 files changed, 10 insertions(+), 624 deletions(-)
 delete mode 100644 config/v2_spec.ts

diff --git a/config/v2_spec.ts b/config/v2_spec.ts
deleted file mode 100644
index 1047832..0000000
--- a/config/v2_spec.ts
+++ /dev/null
@@ -1,616 +0,0 @@
-// deno-lint-ignore-file ban-types
-import { DefaultString } from "../types.ts";
-import { matches } from "../dependencies.ts";
-
-type Validator<A> = matches.Validator<unknown, A>;
-const { shape, boolean, string, dictionary, anyOf, arrayOf, every, deferred, number, recursive, unknown } = matches;
-
-export const [matchConfig, setMatchConfig] = deferred<Config>();
-export type Config = {
-  [key: string]: AnyValue;
-};
-
-export const matchDescription = shape(
-  {
-    name: string,
-    description: string,
-    warning: string,
-  },
-  ["description", "warning"]
-);
-
-export const matchUniqueBy = recursive<_UniqueBy>((x) => anyOf(string, shape({ any: x }))).optional();
-type _UniqueBy = { any: _UniqueBy } | string;
-type UniqueBy = null | undefined | _UniqueBy;
-
-export const matchBoolValue: Validator<BoolValue> = shape({
-  boolean: every(
-    matchDescription,
-    shape({
-      default: boolean,
-    })
-  ),
-});
-export type BoolValue = {
-  boolean: {
-    name: string;
-    description?: string;
-    warning?: string;
-    default: boolean;
-  };
-};
-
-export const matchDefaultString = anyOf(
-  string,
-  shape(
-    {
-      charset: string,
-      len: number,
-    },
-    ["charset"]
-  )
-);
-
-export const matchStringValue: Validator<StringValue> = shape({
-  string: every(
-    shape(
-      {
-        name: string,
-        nullable: boolean,
-        // optionals
-        description: string,
-        warning: string,
-        default: matchDefaultString,
-        copyable: boolean,
-        masked: boolean,
-        placeholder: string,
-      },
-      ["description", "warning", "default", "copyable", "masked", "placeholder"]
-    ),
-    anyOf(
-      shape({}),
-      shape({
-        pattern: string,
-        "pattern-description": string,
-      })
-    )
-  ),
-});
-export type StringValue = {
-  string: {
-    name: string;
-    description?: string;
-    warning?: string;
-    default?: DefaultString;
-    nullable: boolean;
-    copyable?: boolean;
-    masked?: boolean;
-    placeholder?: string;
-  } & (
-    | {}
-    | {
-        pattern: string;
-        "pattern-description": string;
-      }
-  );
-};
-
-export const matchNumberValue: Validator<NumberValue> = shape({
-  number: every(
-    matchDescription,
-    shape(
-      {
-        default: number,
-      },
-      ["default"]
-    )
-  ),
-});
-export type NumberValue = {
-  number: {
-    name: string;
-    default?: number;
-    description?: string;
-    warning?: string;
-  };
-};
-
-export const matchEnumValue: Validator<EnumValue> = shape({
-  enum: shape(
-    {
-      name: string,
-      default: string,
-      values: arrayOf(string),
-      "value-names": dictionary([string, string]),
-      // optionals
-      description: string,
-      warning: string,
-    },
-    ["description", "warning"]
-  ),
-});
-export type EnumValue = {
-  enum: {
-    name: string;
-    default: string;
-    values: string[] | readonly string[];
-    "value-names": {
-      [key: string]: string;
-    };
-    // optionals
-    description?: string;
-    warning?: string;
-  };
-};
-
-const matchListBooleanValue: Validator<ListValue["list"] & { boolean: unknown }> = shape({
-  boolean: shape(
-    {
-      name: string,
-      default: arrayOf(boolean),
-      spec: shape({}),
-      range: string,
-
-      //optionals
-      description: string,
-      warning: string,
-    },
-    ["warning", "description"]
-  ),
-});
-const matchListStringValue: Validator<ListValue["list"] & { string: unknown }> = shape({
-  string: shape(
-    {
-      name: string,
-      default: arrayOf(string),
-      spec: every(
-        shape(
-          {
-            copyable: boolean,
-            masked: boolean,
-            placeholder: string,
-          },
-          ["copyable", "masked", "placeholder"]
-        ),
-        anyOf(
-          shape({}),
-          shape({
-            pattern: string,
-            "pattern-description": string,
-          })
-        )
-      ),
-      range: string,
-
-      //optionals
-      description: string,
-      warning: string,
-    },
-    ["warning", "description"]
-  ),
-});
-const matchListNumberValue: Validator<ListValue["list"] & { number: unknown }> = shape({
-  number: shape(
-    {
-      name: string,
-      default: arrayOf(number),
-      spec: shape(
-        {
-          range: string,
-          integral: boolean,
-          units: string,
-          placeholder: number,
-        },
-        ["range", "integral", "units", "placeholder"]
-      ),
-      range: string,
-
-      //optionals
-      description: string,
-      warning: string,
-    },
-    ["warning", "description"]
-  ),
-});
-const matchListEnumValue: Validator<ListValue["list"] & { enum: unknown }> = shape({
-  enum: shape(
-    {
-      name: string,
-      default: arrayOf(string),
-      spec: shape({
-        values: arrayOf(string),
-        "value-names": dictionary([string, string]),
-      }),
-      range: string,
-
-      //optionals
-      description: string,
-      warning: string,
-    },
-    ["warning", "description"]
-  ),
-});
-const matchListObjectValue: Validator<ListValue["list"] & { object: unknown }> = shape({
-  object: shape(
-    {
-      name: string,
-      spec: shape(
-        {
-          spec: matchConfig,
-          "display-as": string,
-          "unique-by": matchUniqueBy,
-        },
-        ["display-as", "unique-by"]
-      ),
-      range: string,
-
-      //optionals
-      default: arrayOf(dictionary([string, unknown])),
-      description: string,
-      warning: string,
-    },
-    ["default", "warning", "description"]
-  ),
-});
-const matchListUnionValue: Validator<ListValue["list"] & { union: unknown }> = shape({
-  union: shape(
-    {
-      name: string,
-      default: arrayOf(string),
-      spec: shape(
-        {
-          /** What tag for the specification, for tag unions */
-          tag: shape(
-            {
-              id: string,
-              name: string,
-              description: string,
-              "variant-names": dictionary([string, string]),
-            },
-            ["name", "description"]
-          ),
-          /** The possible enum values */
-          variants: dictionary([string, matchConfig]),
-          "display-as": string,
-          "unique-by": matchUniqueBy,
-        },
-        ["display-as", "unique-by"]
-      ),
-      range: string,
-
-      //optionals
-      description: string,
-      warning: string,
-    },
-    ["warning", "description"]
-  ),
-});
-export const matchListValue: Validator<ListValue> = shape({
-  list: anyOf(
-    matchListBooleanValue,
-    matchListStringValue,
-    matchListNumberValue,
-    matchListEnumValue,
-    matchListObjectValue,
-    matchListUnionValue
-  ),
-});
-export type ListValue = {
-  list:
-    | {
-        boolean: {
-          name: string;
-          default: boolean[] | readonly boolean[];
-          spec: {};
-          range: string;
-
-          //optionals
-          description?: string;
-          warning?: string;
-        };
-      }
-    | {
-        string: {
-          name: string;
-          default: string[] | readonly string[];
-          spec:
-            | {
-                copyable?: boolean | undefined;
-                masked?: boolean | undefined;
-                placeholder?: string | undefined;
-              }
-            | ({
-                pattern: string;
-                "pattern-description": string;
-              } & {});
-          range: string;
-
-          //optionals
-          description?: string;
-          warning?: string;
-        };
-      }
-    | {
-        number: {
-          name: string;
-          default: number[] | readonly number[];
-          spec: {
-            range?: string | undefined;
-            integral?: boolean | undefined;
-            units?: string | undefined;
-            placeholder?: number | undefined;
-          };
-          range: string;
-
-          //optionals
-          description?: string;
-          warning?: string;
-        };
-      }
-    | {
-        enum: {
-          name: string;
-          default: string[] | readonly string[];
-          spec: {
-            values: string[] | readonly string[];
-            "value-names": {
-              [key: string]: string;
-            };
-          };
-          range: string;
-
-          //optionals
-          description?: string;
-          warning?: string;
-        };
-      }
-    | {
-        object: {
-          name: string;
-          spec: {
-            spec: Config;
-            "display-as"?: string | undefined;
-            "unique-by"?: UniqueBy | undefined;
-          };
-          range: string;
-
-          //optionals
-          default?: Record<string, unknown>[] | readonly Record<string, unknown>[];
-          description?: string;
-          warning?: string;
-        };
-      }
-    | {
-        union: {
-          name: string;
-          default: string[] | readonly string[];
-          spec: {
-            tag: {
-              id: string;
-              name?: string | undefined;
-              description?: string | undefined;
-              "variant-names": {
-                [key: string]: string;
-              };
-            };
-            variants: {
-              [key: string]: Config;
-            };
-            "display-as"?: string | undefined;
-            "unique-by"?: UniqueBy | undefined;
-          };
-          range: string;
-
-          //optionals
-          description?: string;
-          warning?: string;
-        };
-      };
-};
-
-export const matchObjectValue: Validator<ObjectValue> = shape({
-  object: shape(
-    {
-      name: string,
-      default: matchConfig,
-      values: arrayOf(string),
-      "value-names": dictionary([string, string]),
-      // optionals
-      description: string,
-      warning: string,
-    },
-    ["description", "warning"]
-  ),
-});
-export type ObjectValue = {
-  object: {
-    name: string;
-    default: Config;
-    values: string[] | readonly string[];
-    "value-names": {
-      [key: string]: string;
-    };
-    // optionals
-    description?: string;
-    warning?: string;
-  };
-};
-
-export const matchUnionValue: Validator<UnionValue> = shape({
-  union: shape(
-    {
-      name: string,
-      default: string,
-      tag: shape(
-        {
-          id: string,
-          "variant-names": dictionary([string, string]),
-          // optionals
-          name: string,
-          description: string,
-        },
-        ["name", "description"]
-      ),
-      variants: dictionary([string, matchConfig]),
-
-      //optionals
-      description: string,
-      warning: string,
-      "display-as": string,
-      "unique-by": matchUniqueBy,
-    },
-    ["description", "warning", "display-as", "unique-by"]
-  ),
-});
-export type UnionValue = {
-  union: {
-    name: string;
-    default: string;
-    tag: {
-      id: string;
-      name?: string | undefined;
-      description?: string | undefined;
-      "variant-names": {
-        [key: string]: string;
-      };
-    };
-    variants: {
-      [key: string]: Config;
-    };
-
-    //optionals
-    description?: string;
-    warning?: string;
-    "display-as"?: string | undefined;
-    "unique-by"?: UniqueBy | undefined;
-  };
-};
-
-export const matchPointerValue: Validator<PointerValue> = shape({
-  pointer: every(
-    shape(
-      {
-        name: string,
-
-        //optionals
-        description: string,
-        warning: string,
-      },
-      ["description", "warning"]
-    ),
-    anyOf(
-      shape({
-        package: anyOf(
-          shape({ "tor-key": shape({ "package-id": string, inferface: string }) }),
-          shape({ "tor-address": shape({ "package-id": string, inferface: string }) }),
-          shape({ "lan-address": shape({ "package-id": string, inferface: string }) }),
-          shape({ config: shape({ "package-id": string, selector: string, multi: boolean }, ["multi"]) })
-        ),
-      }),
-      shape({
-        system: dictionary([string, unknown]),
-      })
-    )
-  ),
-});
-export type PointerValue = {
-  pointer: {
-    name: string;
-
-    //optionals
-    description?: string;
-    warning?: string;
-  } & (
-    | {
-        package:
-          | { "tor-key": { "package-id": string; inferface: string } }
-          | { "tor-address": { "package-id": string; inferface: string } }
-          | { "lan-address": { "package-id": string; inferface: string } }
-          | { config: { "package-id": string; selector: string; multi?: boolean } };
-      }
-    | { system: Record<string, unknown> }
-  );
-};
-
-export const matchAnyValue = anyOf(
-  matchBoolValue,
-  matchStringValue,
-  matchNumberValue,
-  matchEnumValue,
-  matchListValue,
-  matchObjectValue,
-  matchUnionValue,
-  matchPointerValue
-);
-export type AnyValue = typeof matchAnyValue._TYPE;
-
-export const matchSpec = dictionary([string, matchAnyValue]);
-export type Spec = typeof matchSpec._TYPE;
-
-export type V2to1Spec<A extends Spec> = {
-  [key in keyof A]: V2to1AnyValue<A[key]>;
-};
-// prettier-ignore
-// deno-fmt-ignore
-export type V2to1AnyValue<A extends AnyValue> = 
-    A extends BoolValue ? (
-        {
-            tag: "boolean",
-        } & A["boolean"]
-    ) :
-    A extends StringValue ? (
-        {
-            tag: "string",
-        } & A["string"]
-    ) :
-    A extends NumberValue ? (
-        {
-            tag: "number",
-        } & A["number"]
-    ) :
-    A extends EnumValue ? (
-        {
-            tag: "enum",
-            subtype: keyof A["enum"]
-        } & A["enum"][keyof A["enum"]]
-    ) :
-    A extends ListValue ? (
-        {
-            tag: "list",
-        } & A["list"]
-    ) :
-    A extends ObjectValue ? (
-        {
-            tag: "object",
-        } & A["object"]
-    ) :
-    A extends PointerValue ? (
-      {
-        name: string, description?: string, warning?: string,}
-        & (
-          A["pointer"] extends {'package': {'tor-key': infer Target }} ? (
-            {tag: "pointer",
-            subtype: 'package', target: 'tor-key' } & Target
-          ) :
-          A["pointer"] extends {'package': {'tor-address': infer Target }} ? (
-            {tag: "pointer",
-            subtype: 'package', target: 'tor-address' } & Target
-          ) :
-          A["pointer"] extends {'package': {'lan-address': infer Target }} ? (
-            {tag: "pointer",
-            subtype: 'package', target: 'lan-address' } & Target
-          ) :
-          A["pointer"] extends {'package': {'config': infer Target }} ? (
-            {tag: "pointer",
-            subtype: 'package', target: 'config' } & Target
-          ) :
-          A["pointer"] extends {'system': infer System } ? (
-            {tag: "pointer",
-            subtype: 'system'} & System
-          ) :
-          never
-        )
-    ) :
-    never
-
-setMatchConfig(dictionary([string, matchAnyValue]));
diff --git a/config/value.ts b/config/value.ts
index 5afa9fa..c87d190 100644
--- a/config/value.ts
+++ b/config/value.ts
@@ -3,7 +3,14 @@ import { Config } from "./config.ts";
 import { List } from "./list.ts";
 import { Pointer } from "./pointer.ts";
 import { Variants } from "./variants.ts";
-import { ConfigSpec, ValueSpec, ValueSpecList, ValueSpecNumber, ValueSpecString } from "../types/config-types.ts";
+import {
+  ConfigSpec,
+  UniqueBy,
+  ValueSpec,
+  ValueSpecList,
+  ValueSpecNumber,
+  ValueSpecString,
+} from "../types/config-types.ts";
 
 export type DefaultString =
   | string
@@ -45,12 +52,6 @@ export type Nullable = {
   nullable: boolean;
 };
 
-type _UniqueBy =
-  | string
-  | {
-      any: _UniqueBy[];
-    };
-
 export class Value<A extends ValueSpec> extends IBuilder<A> {
   static boolean<A extends Description & Default<boolean>>(a: A) {
     return new Value({
@@ -111,7 +112,7 @@ export class Value<A extends ValueSpec> extends IBuilder<A> {
         };
         variants: Variants<B>;
         "display-as": string | null;
-        "unique-by": _UniqueBy;
+        "unique-by": UniqueBy;
       },
     B extends { [key: string]: ConfigSpec }
   >(a: A) {
diff --git a/types/config-types.ts b/types/config-types.ts
index 0483504..6eb6275 100644
--- a/types/config-types.ts
+++ b/types/config-types.ts
@@ -140,6 +140,7 @@ export interface ListValueSpecObject {
 
 export type UniqueBy =
   | null
+  | undefined
   | string
   | { any: readonly UniqueBy[] | UniqueBy[] }
   | { all: readonly UniqueBy[] | UniqueBy[] };