@dxos/effect 0.6.14-staging.e15392e → 0.7.1-staging.599df14

package/dist/lib/node/index.cjs

@@ -20,15 +20,24 @@ var node_exports = {};
 __export(node_exports, {
   AST: () => import_schema.AST,
   JSONSchema: () => import_schema.JSONSchema,
+  JsonPath: () => JsonPath,
+  JsonProp: () => JsonProp,
   ParamKeyAnnotation: () => ParamKeyAnnotation,
   S: () => import_schema.Schema,
   UrlParser: () => UrlParser,
   VisitResult: () => VisitResult,
+  findAnnotation: () => findAnnotation,
+  findNode: () => findNode,
+  findProperty: () => findProperty,
   getAnnotation: () => getAnnotation,
+  getDiscriminatedType: () => getDiscriminatedType,
+  getDiscriminatingProps: () => getDiscriminatingProps,
   getParamKeyAnnotation: () => getParamKeyAnnotation,
-  getProperty: () => getProperty,
-  getType: () => getType,
-  isLeafType: () => isLeafType,
+  getSimpleType: () => getSimpleType,
+  isDiscriminatedUnion: () => isDiscriminatedUnion,
+  isLiteralUnion: () => isLiteralUnion,
+  isOption: () => isOption,
+  isSimpleType: () => isSimpleType,
   visit: () => visit
 });
 module.exports = __toCommonJS(node_exports);
@@ -36,86 +45,262 @@ var import_schema = require("@effect/schema");
 var import_schema2 = require("@effect/schema");
 var import_effect = require("effect");
 var import_invariant = require("@dxos/invariant");
+var import_util = require("@dxos/util");
 var import_schema3 = require("@effect/schema");
 var import_effect2 = require("effect");
-var import_util = require("@dxos/util");
+var import_util2 = require("@dxos/util");
 var __dxlog_file = "/home/runner/work/dxos/dxos/packages/common/effect/src/ast.ts";
-var isLeafType = (node) => !import_schema2.AST.isTupleType(node) && !import_schema2.AST.isTypeLiteral(node);
-var getAnnotation = (annotationId, node) => (0, import_effect.pipe)(import_schema2.AST.getAnnotation(annotationId)(node), import_effect.Option.getOrUndefined);
-var getType = (node) => {
-  if (import_schema2.AST.isUnion(node)) {
-    return node.types.find((type) => getType(type));
-  } else if (import_schema2.AST.isRefinement(node)) {
-    return getType(node.from);
-  } else {
-    return node;
+var getSimpleType = (node) => {
+  if (import_schema2.AST.isObjectKeyword(node) || import_schema2.AST.isTypeLiteral(node) || isDiscriminatedUnion(node)) {
+    return "object";
   }
-};
-var getProperty = (schema, path) => {
-  let node = schema.ast;
-  for (const part of path.split(".")) {
-    const props = import_schema2.AST.getPropertySignatures(node);
-    const prop = props.find((prop2) => prop2.name === part);
-    if (!prop) {
-      return void 0;
-    }
-    const type = getType(prop.type);
-    (0, import_invariant.invariant)(type, `invalid type: ${path}`, {
-      F: __dxlog_file,
-      L: 52,
-      S: void 0,
-      A: [
-        "type",
-        "`invalid type: ${path}`"
-      ]
-    });
-    node = type;
+  if (import_schema2.AST.isStringKeyword(node)) {
+    return "string";
+  }
+  if (import_schema2.AST.isNumberKeyword(node)) {
+    return "number";
+  }
+  if (import_schema2.AST.isBooleanKeyword(node)) {
+    return "boolean";
+  }
+  if (import_schema2.AST.isEnums(node)) {
+    return "enum";
+  }
+  if (import_schema2.AST.isLiteral(node)) {
+    return "literal";
   }
-  return node;
 };
+var isSimpleType = (node) => !!getSimpleType(node);
+var PATH_REGEX = /[a-zA-Z_$][\w$]*(?:\.[a-zA-Z_$][\w$]*)*/;
+var PROP_REGEX = /\w+/;
+var JsonPath = import_schema2.Schema.NonEmptyString.pipe(import_schema2.Schema.pattern(PATH_REGEX));
+var JsonProp = import_schema2.Schema.NonEmptyString.pipe(import_schema2.Schema.pattern(PROP_REGEX));
+var getAnnotation = (annotationId) => (node) => (0, import_effect.pipe)(import_schema2.AST.getAnnotation(annotationId)(node), import_effect.Option.getOrUndefined);
 var VisitResult;
 (function(VisitResult2) {
   VisitResult2[VisitResult2["CONTINUE"] = 0] = "CONTINUE";
   VisitResult2[VisitResult2["SKIP"] = 1] = "SKIP";
   VisitResult2[VisitResult2["EXIT"] = 2] = "EXIT";
 })(VisitResult || (VisitResult = {}));
+var defaultTest = (node) => isSimpleType(node) ? 0 : 1;
 var visit = (node, testOrVisitor, visitor) => {
   if (!visitor) {
-    visitNode(node, void 0, testOrVisitor);
+    visitNode(node, defaultTest, testOrVisitor);
   } else {
     visitNode(node, testOrVisitor, visitor);
   }
 };
 var visitNode = (node, test, visitor, path = [], depth = 0) => {
-  for (const prop of import_schema2.AST.getPropertySignatures(node)) {
-    const currentPath = [
-      ...path,
-      prop.name.toString()
-    ];
-    const type = getType(prop.type);
-    if (type) {
-      const result = test?.(node, path, depth) ?? 0;
-      if (result === 2) {
-        return result;
+  const result = test?.(node, path, depth) ?? 0;
+  if (result === 2) {
+    return result;
+  }
+  if (result !== 1) {
+    visitor(node, path, depth);
+  }
+  if (import_schema2.AST.isTypeLiteral(node)) {
+    for (const prop of import_schema2.AST.getPropertySignatures(node)) {
+      const currentPath = [
+        ...path,
+        prop.name.toString()
+      ];
+      const result2 = visitNode(prop.type, test, visitor, currentPath, depth + 1);
+      if (result2 === 2) {
+        return result2;
+      }
+    }
+  } else if (import_schema2.AST.isTupleType(node)) {
+    for (const [i, element] of node.elements.entries()) {
+      const currentPath = [
+        ...path,
+        i
+      ];
+      const result2 = visitNode(element.type, test, visitor, currentPath, depth);
+      if (result2 === 2) {
+        return result2;
+      }
+    }
+  } else if (import_schema2.AST.isUnion(node)) {
+    for (const type of node.types) {
+      const result2 = visitNode(type, test, visitor, path, depth);
+      if (result2 === 2) {
+        return result2;
       }
-      visitor(type, currentPath, depth);
-      if (result !== 1) {
-        if (import_schema2.AST.isTypeLiteral(type)) {
-          visitNode(type, test, visitor, currentPath, depth + 1);
-        } else if (import_schema2.AST.isTupleType(type)) {
-          for (const [i, elementType] of type.elements.entries()) {
-            const type2 = getType(elementType.type);
-            if (type2) {
-              visitNode(type2, test, visitor, [
-                i,
-                ...currentPath
-              ], depth);
-            }
-          }
+    }
+  } else if (import_schema2.AST.isRefinement(node)) {
+    const result2 = visitNode(node.from, test, visitor, path, depth);
+    if (result2 === 2) {
+      return result2;
+    }
+  }
+};
+var findNode = (node, test) => {
+  if (test(node)) {
+    return node;
+  } else if (import_schema2.AST.isTypeLiteral(node)) {
+    for (const prop of import_schema2.AST.getPropertySignatures(node)) {
+      const child = findNode(prop.type, test);
+      if (child) {
+        return child;
+      }
+    }
+  } else if (import_schema2.AST.isTupleType(node)) {
+    for (const [_, element] of node.elements.entries()) {
+      const child = findNode(element.type, test);
+      if (child) {
+        return child;
+      }
+    }
+  } else if (import_schema2.AST.isUnion(node)) {
+    if (isOption(node)) {
+      for (const type of node.types) {
+        const child = findNode(type, test);
+        if (child) {
+          return child;
         }
       }
     }
+  } else if (import_schema2.AST.isRefinement(node)) {
+    return findNode(node.from, test);
+  }
+};
+var findProperty = (schema, path) => {
+  const getProp = (node, path2) => {
+    const [name, ...rest] = path2;
+    const typeNode = findNode(node, import_schema2.AST.isTypeLiteral);
+    (0, import_invariant.invariant)(typeNode, void 0, {
+      F: __dxlog_file,
+      L: 221,
+      S: void 0,
+      A: [
+        "typeNode",
+        ""
+      ]
+    });
+    for (const prop of import_schema2.AST.getPropertySignatures(typeNode)) {
+      if (prop.name === name) {
+        if (rest.length) {
+          return getProp(prop.type, rest);
+        } else {
+          return prop.type;
+        }
+      }
+    }
+  };
+  return getProp(schema.ast, path.split("."));
+};
+var defaultAnnotations = {
+  ["ObjectKeyword"]: import_schema2.AST.objectKeyword,
+  ["StringKeyword"]: import_schema2.AST.stringKeyword,
+  ["NumberKeyword"]: import_schema2.AST.numberKeyword,
+  ["BooleanKeyword"]: import_schema2.AST.booleanKeyword
+};
+var findAnnotation = (node, annotationId, options) => {
+  const getAnnotationById = getAnnotation(annotationId);
+  const getBaseAnnotation = (node2) => {
+    const value = getAnnotationById(node2);
+    if (value !== void 0) {
+      if (options?.noDefault && value === defaultAnnotations[node2._tag]?.annotations[annotationId]) {
+        return void 0;
+      }
+      return value;
+    }
+    if (import_schema2.AST.isUnion(node2)) {
+      if (isOption(node2)) {
+        return getAnnotationById(node2.types[0]);
+      }
+    }
+  };
+  return getBaseAnnotation(node);
+};
+var isOption = (node) => {
+  return import_schema2.AST.isUnion(node) && node.types.length === 2 && import_schema2.AST.isUndefinedKeyword(node.types[1]);
+};
+var isLiteralUnion = (node) => {
+  return import_schema2.AST.isUnion(node) && node.types.every(import_schema2.AST.isLiteral);
+};
+var isDiscriminatedUnion = (node) => {
+  return import_schema2.AST.isUnion(node) && !!getDiscriminatingProps(node)?.length;
+};
+var getDiscriminatingProps = (node) => {
+  (0, import_invariant.invariant)(import_schema2.AST.isUnion(node), void 0, {
+    F: __dxlog_file,
+    L: 307,
+    S: void 0,
+    A: [
+      "AST.isUnion(node)",
+      ""
+    ]
+  });
+  if (isOption(node)) {
+    return;
+  }
+  return node.types.reduce((shared, type) => {
+    const props = import_schema2.AST.getPropertySignatures(type).filter((p) => import_schema2.AST.isLiteral(p.type)).map((p) => p.name.toString());
+    return shared.length === 0 ? props : shared.filter((prop) => props.includes(prop));
+  }, []);
+};
+var getDiscriminatedType = (node, value = {}) => {
+  (0, import_invariant.invariant)(import_schema2.AST.isUnion(node), void 0, {
+    F: __dxlog_file,
+    L: 328,
+    S: void 0,
+    A: [
+      "AST.isUnion(node)",
+      ""
+    ]
+  });
+  (0, import_invariant.invariant)(value, void 0, {
+    F: __dxlog_file,
+    L: 329,
+    S: void 0,
+    A: [
+      "value",
+      ""
+    ]
+  });
+  const props = getDiscriminatingProps(node);
+  if (!props?.length) {
+    return;
+  }
+  for (const type of node.types) {
+    const match = import_schema2.AST.getPropertySignatures(type).filter((prop) => props?.includes(prop.name.toString())).every((prop) => {
+      (0, import_invariant.invariant)(import_schema2.AST.isLiteral(prop.type), void 0, {
+        F: __dxlog_file,
+        L: 340,
+        S: void 0,
+        A: [
+          "AST.isLiteral(prop.type)",
+          ""
+        ]
+      });
+      return prop.type.literal === value[prop.name.toString()];
+    });
+    if (match) {
+      return type;
+    }
   }
+  const fields = Object.fromEntries(props.map((prop) => {
+    const literals = node.types.map((type) => {
+      const literal = import_schema2.AST.getPropertySignatures(type).find((p) => p.name.toString() === prop);
+      (0, import_invariant.invariant)(import_schema2.AST.isLiteral(literal.type), void 0, {
+        F: __dxlog_file,
+        L: 358,
+        S: void 0,
+        A: [
+          "AST.isLiteral(literal.type)",
+          ""
+        ]
+      });
+      return literal.type.literal;
+    }).filter(import_util.nonNullable);
+    return literals.length ? [
+      prop,
+      import_schema2.Schema.Literal(...literals)
+    ] : void 0;
+  }).filter(import_util.nonNullable));
+  const schema = import_schema2.Schema.Struct(fields);
+  return schema.ast;
 };
 var ParamKeyAnnotationId = Symbol.for("@dxos/schema/annotation/ParamKey");
 var getParamKeyAnnotation = import_schema3.AST.getAnnotation(ParamKeyAnnotationId);
@@ -132,7 +317,7 @@ var UrlParser = class {
   parse(_url) {
     const url = new URL(_url);
     return Object.entries(this._schema.fields).reduce((params, [key, type]) => {
-      let value = url.searchParams.get((0, import_util.decamelize)(key));
+      let value = url.searchParams.get((0, import_util2.decamelize)(key));
       if (value == null) {
         value = url.searchParams.get(key);
       }
@@ -158,7 +343,7 @@ var UrlParser = class {
         const field = this._schema.fields[key];
         if (field) {
           const { key: serializedKey } = (0, import_effect2.pipe)(getParamKeyAnnotation(field.ast), import_effect2.Option.getOrElse(() => ({
-            key: (0, import_util.decamelize)(key)
+            key: (0, import_util2.decamelize)(key)
           })));
           url.searchParams.set(serializedKey, String(value));
         }
@@ -171,15 +356,24 @@ var UrlParser = class {
 0 && (module.exports = {
   AST,
   JSONSchema,
+  JsonPath,
+  JsonProp,
   ParamKeyAnnotation,
   S,
   UrlParser,
   VisitResult,
+  findAnnotation,
+  findNode,
+  findProperty,
   getAnnotation,
+  getDiscriminatedType,
+  getDiscriminatingProps,
   getParamKeyAnnotation,
-  getProperty,
-  getType,
-  isLeafType,
+  getSimpleType,
+  isDiscriminatedUnion,
+  isLiteralUnion,
+  isOption,
+  isSimpleType,
   visit
 });
 //# sourceMappingURL=index.cjs.map

package/dist/lib/node/index.cjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/index.ts", "../../../src/ast.ts", "../../../src/url.ts"],
-  "sourcesContent": ["//\n// Copyright 2020 DXOS.org\n//\n\nimport { AST, JSONSchema, Schema as S } from '@effect/schema';\nimport type * as Types from 'effect/Types';\n\nexport { AST, JSONSchema, S, Types };\n\nexport * from './ast';\nexport * from './url';\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport { AST, type Schema as S } from '@effect/schema';\nimport { Option, pipe } from 'effect';\n\nimport { invariant } from '@dxos/invariant';\n\n//\n// Refs\n// https://effect.website/docs/guides/schema\n// https://www.npmjs.com/package/@effect/schema\n// https://effect-ts.github.io/effect/schema/AST.ts.html\n//\n\nexport const isLeafType = (node: AST.AST) => !AST.isTupleType(node) && !AST.isTypeLiteral(node);\n\n/**\n * Get annotation or return undefined.\n */\nexport const getAnnotation = <T>(annotationId: symbol, node: AST.Annotated): T | undefined =>\n  pipe(AST.getAnnotation<T>(annotationId)(node), Option.getOrUndefined);\n\n/**\n * Get type node.\n */\nexport const getType = (node: AST.AST): AST.AST | undefined => {\n  if (AST.isUnion(node)) {\n    return node.types.find((type) => getType(type));\n  } else if (AST.isRefinement(node)) {\n    return getType(node.from);\n  } else {\n    return node;\n  }\n};\n\n/**\n * Get the AST node for the given property (dot-path).\n */\nexport const getProperty = (schema: S.Schema<any>, path: string): AST.AST | undefined => {\n  let node: AST.AST = schema.ast;\n  for (const part of path.split('.')) {\n    const props = AST.getPropertySignatures(node);\n    const prop = props.find((prop) => prop.name === part);\n    if (!prop) {\n      return undefined;\n    }\n\n    // TODO(burdon): Check if leaf.\n    const type = getType(prop.type);\n    invariant(type, `invalid type: ${path}`);\n    node = type;\n  }\n\n  return node;\n};\n\nexport enum VisitResult {\n  CONTINUE = 0,\n  /**\n   * Skip visiting children.\n   */\n  SKIP = 1,\n  /**\n   * Stop traversing immeditaely.\n   */\n  EXIT = 2,\n}\n\nexport type Path = (string | number)[];\n\nexport type Tester = (node: AST.AST, path: Path, depth: number) => VisitResult;\nexport type Visitor = (node: AST.AST, path: Path, depth: number) => void;\n\n/**\n * Visit leaf nodes.\n * Refs:\n * - https://github.com/syntax-tree/unist-util-visit?tab=readme-ov-file#visitor\n * - https://github.com/syntax-tree/unist-util-is?tab=readme-ov-file#test\n */\nexport const visit: {\n  (node: AST.AST, visitor: Visitor): void;\n  (node: AST.AST, test: Tester, visitor: Visitor): void;\n} = (node: AST.AST, testOrVisitor: Tester | Visitor, visitor?: Visitor): void => {\n  if (!visitor) {\n    visitNode(node, undefined, testOrVisitor);\n  } else {\n    visitNode(node, testOrVisitor as Tester, visitor);\n  }\n};\n\nconst visitNode = (\n  node: AST.AST,\n  test: Tester | undefined,\n  visitor: Visitor,\n  path: Path = [],\n  depth = 0,\n): VisitResult | undefined => {\n  for (const prop of AST.getPropertySignatures(node)) {\n    const currentPath = [...path, prop.name.toString()];\n    const type = getType(prop.type);\n    if (type) {\n      const result = test?.(node, path, depth) ?? VisitResult.CONTINUE;\n      if (result === VisitResult.EXIT) {\n        return result;\n      }\n\n      visitor(type, currentPath, depth);\n\n      if (result !== VisitResult.SKIP) {\n        if (AST.isTypeLiteral(type)) {\n          visitNode(type, test, visitor, currentPath, depth + 1);\n        } else if (AST.isTupleType(type)) {\n          for (const [i, elementType] of type.elements.entries()) {\n            const type = getType(elementType.type);\n            if (type) {\n              visitNode(type, test, visitor, [i, ...currentPath], depth);\n            }\n          }\n        }\n      }\n    }\n  }\n};\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport { AST, type Schema as S } from '@effect/schema';\nimport { Option, pipe } from 'effect';\n\nimport { decamelize } from '@dxos/util';\n\nconst ParamKeyAnnotationId = Symbol.for('@dxos/schema/annotation/ParamKey');\n\ntype ParamKeyAnnotationValue = { key: string };\n\nexport const getParamKeyAnnotation: (annotated: AST.Annotated) => Option.Option<ParamKeyAnnotationValue> =\n  AST.getAnnotation<ParamKeyAnnotationValue>(ParamKeyAnnotationId);\n\nexport const ParamKeyAnnotation =\n  (value: ParamKeyAnnotationValue) =>\n  <S extends S.Annotable.All>(self: S): S.Annotable.Self<S> =>\n    self.annotations({ [ParamKeyAnnotationId]: value });\n\n/**\n * HTTP params parser.\n * Supports custom key serialization.\n */\nexport class UrlParser<T extends Record<string, any>> {\n  constructor(private readonly _schema: S.Struct<T>) {}\n\n  /**\n   * Parse URL params.\n   */\n  parse(_url: string): T {\n    const url = new URL(_url);\n    return Object.entries(this._schema.fields).reduce<Record<string, any>>((params, [key, type]) => {\n      let value = url.searchParams.get(decamelize(key));\n      if (value == null) {\n        value = url.searchParams.get(key);\n      }\n\n      if (value != null) {\n        if (AST.isNumberKeyword(type.ast)) {\n          params[key] = parseInt(value);\n        } else if (AST.isBooleanKeyword(type.ast)) {\n          params[key] = value === 'true' || value === '1';\n        } else {\n          params[key] = value;\n        }\n      }\n\n      return params;\n    }, {}) as T;\n  }\n\n  /**\n   * Return URL with encoded params.\n   */\n  create(_url: string, params: T): URL {\n    const url = new URL(_url);\n    Object.entries(params).forEach(([key, value]) => {\n      if (value !== undefined) {\n        const field = this._schema.fields[key];\n        if (field) {\n          const { key: serializedKey } = pipe(\n            getParamKeyAnnotation(field.ast),\n            Option.getOrElse(() => ({\n              key: decamelize(key),\n            })),\n          );\n\n          url.searchParams.set(serializedKey, String(value));\n        }\n      }\n    });\n\n    return url;\n  }\n}\n"],
-  "mappings": "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",
-  "names": ["import_schema", "import_effect", "isLeafType", "node", "AST", "isTupleType", "isTypeLiteral", "getAnnotation", "annotationId", "pipe", "Option", "getOrUndefined", "getType", "isUnion", "types", "find", "type", "isRefinement", "from", "getProperty", "schema", "path", "ast", "part", "split", "props", "getPropertySignatures", "prop", "name", "undefined", "invariant", "VisitResult", "visit", "testOrVisitor", "visitor", "visitNode", "test", "depth", "currentPath", "toString", "result", "i", "elementType", "elements", "entries", "ParamKeyAnnotationId", "Symbol", "for", "getParamKeyAnnotation", "ParamKeyAnnotation", "value", "self", "annotations", "UrlParser", "constructor", "_schema", "parse", "_url", "url", "URL", "Object", "fields", "reduce", "params", "key", "searchParams", "get", "decamelize", "isNumberKeyword", "parseInt", "isBooleanKeyword", "create", "forEach", "field", "serializedKey", "getOrElse", "set", "String"]
+  "sourcesContent": ["//\n// Copyright 2020 DXOS.org\n//\n\nimport { AST, JSONSchema, Schema as S } from '@effect/schema';\nimport type * as Types from 'effect/Types';\n\n// TODO(dmaretskyi): Remove re-exports.\nexport { AST, JSONSchema, S, Types };\n\nexport * from './ast';\nexport * from './url';\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport { AST, Schema as S } from '@effect/schema';\nimport { Option, pipe } from 'effect';\n\nimport { invariant } from '@dxos/invariant';\nimport { nonNullable } from '@dxos/util';\n\n//\n// Refs\n// https://effect.website/docs/schema/introduction\n// https://www.npmjs.com/package/@effect/schema\n// https://effect-ts.github.io/effect/schema/AST.ts.html\n//\n\nexport type SimpleType = 'object' | 'string' | 'number' | 'boolean' | 'enum' | 'literal';\n\n/**\n * Get the base type; e.g., traverse through refinements.\n */\nexport const getSimpleType = (node: AST.AST): SimpleType | undefined => {\n  if (AST.isObjectKeyword(node) || AST.isTypeLiteral(node) || isDiscriminatedUnion(node)) {\n    return 'object';\n  }\n\n  if (AST.isStringKeyword(node)) {\n    return 'string';\n  }\n  if (AST.isNumberKeyword(node)) {\n    return 'number';\n  }\n  if (AST.isBooleanKeyword(node)) {\n    return 'boolean';\n  }\n\n  if (AST.isEnums(node)) {\n    return 'enum';\n  }\n\n  if (AST.isLiteral(node)) {\n    return 'literal';\n  }\n};\n\nexport const isSimpleType = (node: AST.AST): boolean => !!getSimpleType(node);\n\n//\n// Branded types\n//\n\nexport type JsonProp = string & { __JsonPath: true; __JsonProp: true };\nexport type JsonPath = string & { __JsonPath: true };\n\nconst PATH_REGEX = /[a-zA-Z_$][\\w$]*(?:\\.[a-zA-Z_$][\\w$]*)*/;\nconst PROP_REGEX = /\\w+/;\n\n/**\n * https://www.ietf.org/archive/id/draft-goessner-dispatch-jsonpath-00.html\n */\nexport const JsonPath = S.NonEmptyString.pipe(S.pattern(PATH_REGEX)) as any as S.Schema<JsonPath>;\nexport const JsonProp = S.NonEmptyString.pipe(S.pattern(PROP_REGEX)) as any as S.Schema<JsonProp>;\n\n/**\n * Get annotation or return undefined.\n */\nexport const getAnnotation =\n  <T>(annotationId: symbol) =>\n  (node: AST.Annotated): T | undefined =>\n    pipe(AST.getAnnotation<T>(annotationId)(node), Option.getOrUndefined);\n\nexport enum VisitResult {\n  CONTINUE = 0,\n  /**\n   * Skip visiting children.\n   */\n  SKIP = 1,\n  /**\n   * Stop traversing immediately.\n   */\n  EXIT = 2,\n}\n\nexport type Path = (string | number)[];\n\nexport type Tester = (node: AST.AST, path: Path, depth: number) => VisitResult | undefined;\nexport type Visitor = (node: AST.AST, path: Path, depth: number) => void;\n\nconst defaultTest: Tester = (node) => (isSimpleType(node) ? VisitResult.CONTINUE : VisitResult.SKIP);\n\n/**\n * Visit leaf nodes.\n * Refs:\n * - https://github.com/syntax-tree/unist-util-visit?tab=readme-ov-file#visitor\n * - https://github.com/syntax-tree/unist-util-is?tab=readme-ov-file#test\n */\nexport const visit: {\n  (node: AST.AST, visitor: Visitor): void;\n  (node: AST.AST, test: Tester, visitor: Visitor): void;\n} = (node: AST.AST, testOrVisitor: Tester | Visitor, visitor?: Visitor): void => {\n  if (!visitor) {\n    visitNode(node, defaultTest, testOrVisitor);\n  } else {\n    visitNode(node, testOrVisitor as Tester, visitor);\n  }\n};\n\nconst visitNode = (\n  node: AST.AST,\n  test: Tester | undefined,\n  visitor: Visitor,\n  path: Path = [],\n  depth = 0,\n): VisitResult | undefined => {\n  const result = test?.(node, path, depth) ?? VisitResult.CONTINUE;\n  if (result === VisitResult.EXIT) {\n    return result;\n  }\n  if (result !== VisitResult.SKIP) {\n    visitor(node, path, depth);\n  }\n\n  // Object.\n  if (AST.isTypeLiteral(node)) {\n    for (const prop of AST.getPropertySignatures(node)) {\n      const currentPath = [...path, prop.name.toString()];\n      const result = visitNode(prop.type, test, visitor, currentPath, depth + 1);\n      if (result === VisitResult.EXIT) {\n        return result;\n      }\n    }\n  }\n\n  // Array.\n  else if (AST.isTupleType(node)) {\n    for (const [i, element] of node.elements.entries()) {\n      const currentPath = [...path, i];\n      const result = visitNode(element.type, test, visitor, currentPath, depth);\n      if (result === VisitResult.EXIT) {\n        return result;\n      }\n    }\n  }\n\n  // Branching union (e.g., optional, discriminated unions).\n  else if (AST.isUnion(node)) {\n    for (const type of node.types) {\n      const result = visitNode(type, test, visitor, path, depth);\n      if (result === VisitResult.EXIT) {\n        return result;\n      }\n    }\n  }\n\n  // Refinement.\n  else if (AST.isRefinement(node)) {\n    const result = visitNode(node.from, test, visitor, path, depth);\n    if (result === VisitResult.EXIT) {\n      return result;\n    }\n  }\n\n  // TODO(burdon): Transforms?\n};\n\n/**\n * Recursively descend into AST to find first node that passes the test.\n */\n// TODO(burdon): Rewrite using visitNode?\nexport const findNode = (node: AST.AST, test: (node: AST.AST) => boolean): AST.AST | undefined => {\n  if (test(node)) {\n    return node;\n  }\n\n  // Object.\n  else if (AST.isTypeLiteral(node)) {\n    for (const prop of AST.getPropertySignatures(node)) {\n      const child = findNode(prop.type, test);\n      if (child) {\n        return child;\n      }\n    }\n  }\n\n  // Tuple.\n  else if (AST.isTupleType(node)) {\n    for (const [_, element] of node.elements.entries()) {\n      const child = findNode(element.type, test);\n      if (child) {\n        return child;\n      }\n    }\n  }\n\n  // Branching union (e.g., optional, discriminated unions).\n  else if (AST.isUnion(node)) {\n    if (isOption(node)) {\n      for (const type of node.types) {\n        const child = findNode(type, test);\n        if (child) {\n          return child;\n        }\n      }\n    }\n  }\n\n  // Refinement.\n  else if (AST.isRefinement(node)) {\n    return findNode(node.from, test);\n  }\n};\n\n/**\n * Get the AST node for the given property (dot-path).\n */\nexport const findProperty = (schema: S.Schema<any>, path: JsonPath | JsonProp): AST.AST | undefined => {\n  const getProp = (node: AST.AST, path: JsonProp[]): AST.AST | undefined => {\n    const [name, ...rest] = path;\n    const typeNode = findNode(node, AST.isTypeLiteral);\n    invariant(typeNode);\n    for (const prop of AST.getPropertySignatures(typeNode)) {\n      if (prop.name === name) {\n        if (rest.length) {\n          return getProp(prop.type, rest);\n        } else {\n          return prop.type;\n        }\n      }\n    }\n  };\n\n  return getProp(schema.ast, path.split('.') as JsonProp[]);\n};\n\n//\n// Annotations\n//\n\nconst defaultAnnotations: Record<string, AST.Annotated> = {\n  ['ObjectKeyword' as const]: AST.objectKeyword,\n  ['StringKeyword' as const]: AST.stringKeyword,\n  ['NumberKeyword' as const]: AST.numberKeyword,\n  ['BooleanKeyword' as const]: AST.booleanKeyword,\n};\n\n/**\n * Recursively descend into AST to find first matching annotations.\n * Optionally skips default annotations for basic types (e.g., 'a string').\n */\nexport const findAnnotation = <T>(\n  node: AST.AST,\n  annotationId: symbol,\n  options?: { noDefault: boolean },\n): T | undefined => {\n  const getAnnotationById = getAnnotation(annotationId);\n\n  const getBaseAnnotation = (node: AST.AST): T | undefined => {\n    const value = getAnnotationById(node);\n    if (value !== undefined) {\n      if (options?.noDefault && value === defaultAnnotations[node._tag]?.annotations[annotationId]) {\n        return undefined;\n      }\n\n      return value as T;\n    }\n\n    if (AST.isUnion(node)) {\n      if (isOption(node)) {\n        return getAnnotationById(node.types[0]) as T;\n      }\n    }\n  };\n\n  return getBaseAnnotation(node);\n};\n\n//\n// Unions\n//\n\n/**\n * Effect S.optional creates a union type with undefined as the second type.\n */\nexport const isOption = (node: AST.AST): boolean => {\n  return AST.isUnion(node) && node.types.length === 2 && AST.isUndefinedKeyword(node.types[1]);\n};\n\n/**\n * Determines if the node is a union of literal types.\n */\nexport const isLiteralUnion = (node: AST.AST): boolean => {\n  return AST.isUnion(node) && node.types.every(AST.isLiteral);\n};\n\n/**\n * Determines if the node is a discriminated union.\n */\nexport const isDiscriminatedUnion = (node: AST.AST): boolean => {\n  return AST.isUnion(node) && !!getDiscriminatingProps(node)?.length;\n};\n\n/**\n * Get the discriminating properties for the given union type.\n */\nexport const getDiscriminatingProps = (node: AST.AST): string[] | undefined => {\n  invariant(AST.isUnion(node));\n  if (isOption(node)) {\n    return;\n  }\n\n  // Get common literals across all types.\n  return node.types.reduce<string[]>((shared, type) => {\n    const props = AST.getPropertySignatures(type)\n      // TODO(burdon): Should check each literal is unique.\n      .filter((p) => AST.isLiteral(p.type))\n      .map((p) => p.name.toString());\n\n    // Return common literals.\n    return shared.length === 0 ? props : shared.filter((prop) => props.includes(prop));\n  }, []);\n};\n\n/**\n * Get the discriminated type for the given value.\n */\nexport const getDiscriminatedType = (node: AST.AST, value: Record<string, any> = {}): AST.AST | undefined => {\n  invariant(AST.isUnion(node));\n  invariant(value);\n  const props = getDiscriminatingProps(node);\n  if (!props?.length) {\n    return;\n  }\n\n  // Match provided values.\n  for (const type of node.types) {\n    const match = AST.getPropertySignatures(type)\n      .filter((prop) => props?.includes(prop.name.toString()))\n      .every((prop) => {\n        invariant(AST.isLiteral(prop.type));\n        return prop.type.literal === value[prop.name.toString()];\n      });\n\n    if (match) {\n      return type;\n    }\n  }\n\n  // Create union of discriminating properties.\n  // NOTE: This may not work with non-overlapping variants.\n  // TODO(burdon): Iterate through props and knock-out variants that don't match.\n  const fields = Object.fromEntries(\n    props\n      .map((prop) => {\n        const literals = node.types\n          .map((type) => {\n            const literal = AST.getPropertySignatures(type).find((p) => p.name.toString() === prop)!;\n            invariant(AST.isLiteral(literal.type));\n            return literal.type.literal;\n          })\n          .filter(nonNullable);\n\n        return literals.length ? [prop, S.Literal(...literals)] : undefined;\n      })\n      .filter(nonNullable),\n  );\n\n  const schema = S.Struct(fields);\n  return schema.ast;\n};\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport { AST, type Schema as S } from '@effect/schema';\nimport { Option, pipe } from 'effect';\n\nimport { decamelize } from '@dxos/util';\n\nconst ParamKeyAnnotationId = Symbol.for('@dxos/schema/annotation/ParamKey');\n\ntype ParamKeyAnnotationValue = { key: string };\n\nexport const getParamKeyAnnotation: (annotated: AST.Annotated) => Option.Option<ParamKeyAnnotationValue> =\n  AST.getAnnotation<ParamKeyAnnotationValue>(ParamKeyAnnotationId);\n\nexport const ParamKeyAnnotation =\n  (value: ParamKeyAnnotationValue) =>\n  <S extends S.Annotable.All>(self: S): S.Annotable.Self<S> =>\n    self.annotations({ [ParamKeyAnnotationId]: value });\n\n/**\n * HTTP params parser.\n * Supports custom key serialization.\n */\nexport class UrlParser<T extends Record<string, any>> {\n  constructor(private readonly _schema: S.Struct<T>) {}\n\n  /**\n   * Parse URL params.\n   */\n  parse(_url: string): T {\n    const url = new URL(_url);\n    return Object.entries(this._schema.fields).reduce<Record<string, any>>((params, [key, type]) => {\n      let value = url.searchParams.get(decamelize(key));\n      if (value == null) {\n        value = url.searchParams.get(key);\n      }\n\n      if (value != null) {\n        if (AST.isNumberKeyword(type.ast)) {\n          params[key] = parseInt(value);\n        } else if (AST.isBooleanKeyword(type.ast)) {\n          params[key] = value === 'true' || value === '1';\n        } else {\n          params[key] = value;\n        }\n      }\n\n      return params;\n    }, {}) as T;\n  }\n\n  /**\n   * Return URL with encoded params.\n   */\n  create(_url: string, params: T): URL {\n    const url = new URL(_url);\n    Object.entries(params).forEach(([key, value]) => {\n      if (value !== undefined) {\n        const field = this._schema.fields[key];\n        if (field) {\n          const { key: serializedKey } = pipe(\n            getParamKeyAnnotation(field.ast),\n            Option.getOrElse(() => ({\n              key: decamelize(key),\n            })),\n          );\n\n          url.searchParams.set(serializedKey, String(value));\n        }\n      }\n    });\n\n    return url;\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["import_schema", "import_effect", "import_util", "getSimpleType", "node", "AST", "isObjectKeyword", "isTypeLiteral", "isDiscriminatedUnion", "isStringKeyword", "isNumberKeyword", "isBooleanKeyword", "isEnums", "isLiteral", "isSimpleType", "PATH_REGEX", "PROP_REGEX", "JsonPath", "S", "NonEmptyString", "pipe", "pattern", "JsonProp", "getAnnotation", "annotationId", "Option", "getOrUndefined", "VisitResult", "defaultTest", "visit", "testOrVisitor", "visitor", "visitNode", "test", "path", "depth", "result", "prop", "getPropertySignatures", "currentPath", "name", "toString", "type", "isTupleType", "i", "element", "elements", "entries", "isUnion", "types", "isRefinement", "from", "findNode", "child", "_", "isOption", "findProperty", "schema", "getProp", "rest", "typeNode", "invariant", "length", "ast", "split", "defaultAnnotations", "objectKeyword", "stringKeyword", "numberKeyword", "booleanKeyword", "findAnnotation", "options", "getAnnotationById", "getBaseAnnotation", "value", "undefined", "noDefault", "_tag", "annotations", "isUndefinedKeyword", "isLiteralUnion", "every", "getDiscriminatingProps", "reduce", "shared", "props", "filter", "p", "map", "includes", "getDiscriminatedType", "match", "literal", "fields", "Object", "fromEntries", "literals", "find", "nonNullable", "Literal", "Struct", "ParamKeyAnnotationId", "Symbol", "for", "getParamKeyAnnotation", "ParamKeyAnnotation", "self", "UrlParser", "constructor", "_schema", "parse", "_url", "url", "URL", "params", "key", "searchParams", "get", "decamelize", "parseInt", "create", "forEach", "field", "serializedKey", "getOrElse", "set", "String"]
 }

package/dist/lib/node/meta.json

@@ -1 +1 @@
-{"inputs":{"packages/common/effect/src/ast.ts":{"bytes":11581,"imports":[{"path":"@effect/schema","kind":"import-statement","external":true},{"path":"effect","kind":"import-statement","external":true},{"path":"@dxos/invariant","kind":"import-statement","external":true}],"format":"esm"},"packages/common/effect/src/url.ts":{"bytes":7711,"imports":[{"path":"@effect/schema","kind":"import-statement","external":true},{"path":"effect","kind":"import-statement","external":true},{"path":"@dxos/util","kind":"import-statement","external":true}],"format":"esm"},"packages/common/effect/src/index.ts":{"bytes":1034,"imports":[{"path":"@effect/schema","kind":"import-statement","external":true},{"path":"packages/common/effect/src/ast.ts","kind":"import-statement","original":"./ast"},{"path":"packages/common/effect/src/url.ts","kind":"import-statement","original":"./url"}],"format":"esm"}},"outputs":{"packages/common/effect/dist/lib/node/index.cjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":10201},"packages/common/effect/dist/lib/node/index.cjs":{"imports":[{"path":"@effect/schema","kind":"import-statement","external":true},{"path":"@effect/schema","kind":"import-statement","external":true},{"path":"effect","kind":"import-statement","external":true},{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"@effect/schema","kind":"import-statement","external":true},{"path":"effect","kind":"import-statement","external":true},{"path":"@dxos/util","kind":"import-statement","external":true}],"exports":["AST","JSONSchema","ParamKeyAnnotation","S","UrlParser","VisitResult","getAnnotation","getParamKeyAnnotation","getProperty","getType","isLeafType","visit"],"entryPoint":"packages/common/effect/src/index.ts","inputs":{"packages/common/effect/src/index.ts":{"bytesInOutput":71},"packages/common/effect/src/ast.ts":{"bytesInOutput":2437},"packages/common/effect/src/url.ts":{"bytesInOutput":1624}},"bytes":4468}}}
+{"inputs":{"packages/common/effect/src/ast.ts":{"bytes":33857,"imports":[{"path":"@effect/schema","kind":"import-statement","external":true},{"path":"effect","kind":"import-statement","external":true},{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"@dxos/util","kind":"import-statement","external":true}],"format":"esm"},"packages/common/effect/src/url.ts":{"bytes":7711,"imports":[{"path":"@effect/schema","kind":"import-statement","external":true},{"path":"effect","kind":"import-statement","external":true},{"path":"@dxos/util","kind":"import-statement","external":true}],"format":"esm"},"packages/common/effect/src/index.ts":{"bytes":1150,"imports":[{"path":"@effect/schema","kind":"import-statement","external":true},{"path":"packages/common/effect/src/ast.ts","kind":"import-statement","original":"./ast"},{"path":"packages/common/effect/src/url.ts","kind":"import-statement","original":"./url"}],"format":"esm"}},"outputs":{"packages/common/effect/dist/lib/node/index.cjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":21745},"packages/common/effect/dist/lib/node/index.cjs":{"imports":[{"path":"@effect/schema","kind":"import-statement","external":true},{"path":"@effect/schema","kind":"import-statement","external":true},{"path":"effect","kind":"import-statement","external":true},{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"@dxos/util","kind":"import-statement","external":true},{"path":"@effect/schema","kind":"import-statement","external":true},{"path":"effect","kind":"import-statement","external":true},{"path":"@dxos/util","kind":"import-statement","external":true}],"exports":["AST","JSONSchema","JsonPath","JsonProp","ParamKeyAnnotation","S","UrlParser","VisitResult","findAnnotation","findNode","findProperty","getAnnotation","getDiscriminatedType","getDiscriminatingProps","getParamKeyAnnotation","getSimpleType","isDiscriminatedUnion","isLiteralUnion","isOption","isSimpleType","visit"],"entryPoint":"packages/common/effect/src/index.ts","inputs":{"packages/common/effect/src/index.ts":{"bytesInOutput":72},"packages/common/effect/src/ast.ts":{"bytesInOutput":7227},"packages/common/effect/src/url.ts":{"bytesInOutput":1624}},"bytes":9432}}}