@dxos/echo 0.8.4-main.84f28bd → 0.8.4-main.937b3ca

package/dist/lib/node-esm/chunk-QYR67VBV.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Filter.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Match from 'effect/Match';\nimport * as Schema from 'effect/Schema';\nimport type * as Types from 'effect/Types';\n\nimport { type ForeignKey, type QueryAST } from '@dxos/echo-protocol';\nimport { assertArgument } from '@dxos/invariant';\nimport { DXN, ObjectId } from '@dxos/keys';\n\nimport { getTypeDXNFromSpecifier } from './internal';\nimport * as Ref from './Ref';\n\nexport interface Filter<T> {\n  // TODO(dmaretskyi): See new effect-schema approach to variance.\n  '~Filter': { value: Types.Contravariant<T> };\n\n  ast: QueryAST.Filter;\n}\n\nexport type Props<T> = {\n  // Predicate or a value as a shorthand for `eq`.\n  [K in keyof T & string]?: Filter<T[K]> | T[K];\n};\n\nexport type Any = Filter<any>;\n\nexport type Type<F extends Any> = F extends Filter<infer T> ? T : never;\n\nclass FilterClass implements Any {\n  private static variance: Any['~Filter'] = {} as Any['~Filter'];\n\n  constructor(public readonly ast: QueryAST.Filter) {}\n\n  '~Filter' = FilterClass.variance;\n}\n\nexport const is = (value: unknown): value is Any => {\n  return typeof value === 'object' && value !== null && '~Filter' in value;\n};\n\n/** Construct a filter from an ast. */\nexport const fromAst = (ast: QueryAST.Filter): Any => {\n  return new FilterClass(ast);\n};\n\n/**\n * Filter that matches all objects.\n */\n// TODO(dmaretskyi): `Entity.Any` would be more type-safe, but causes annoying errors in existing code\nexport const everything = (): FilterClass => {\n  return new FilterClass({\n    type: 'object',\n    typename: null,\n    props: {},\n  });\n};\n\n/**\n * Filter that matches no objects.\n */\nexport const nothing = (): FilterClass => {\n  return new FilterClass({\n    type: 'not',\n    filter: {\n      type: 'object',\n      typename: null,\n      props: {},\n    },\n  });\n};\n\n/*\n * Filter by ObjectId.\n */\nexport const id = (...ids: ObjectId[]): Any => {\n  assertArgument(\n    ids.every((id) => ObjectId.isValid(id)),\n    'ids',\n    'ids must be valid',\n  );\n\n  if (ids.length === 0) {\n    return nothing();\n  }\n\n  return new FilterClass({\n    type: 'object',\n    typename: null,\n    id: ids,\n    props: {},\n  });\n};\n\n/**\n * Filter by type.\n */\nexport const type = <S extends Schema.Schema.All>(\n  schema: S | string,\n  props?: Props<Schema.Schema.Type<S>>,\n): Filter<Schema.Schema.Type<S>> => {\n  const dxn = getTypeDXNFromSpecifier(schema);\n  return new FilterClass({\n    type: 'object',\n    typename: dxn.toString(),\n    ...propsFilterToAst(props ?? {}),\n  });\n};\n\n/**\n * Filter by non-qualified typename.\n */\nexport const typename = (typename: string): Any => {\n  assertArgument(!typename.startsWith('dxn:'), 'typename', 'Typename must no be qualified');\n  return new FilterClass({\n    type: 'object',\n    typename: DXN.fromTypename(typename).toString(),\n    props: {},\n  });\n};\n\n/**\n * Filter by fully qualified type DXN.\n */\nexport const typeDXN = (dxn: DXN): Any => {\n  return new FilterClass({\n    type: 'object',\n    typename: dxn.toString(),\n    props: {},\n  });\n};\n\n/**\n * Filter by tag.\n */\nexport const tag = (tag: string): Any => {\n  return new FilterClass({\n    type: 'tag',\n    tag,\n  });\n};\n\n/**\n * Filter by properties.\n */\nexport const props = <T>(props: Props<T>): Filter<T> => {\n  return new FilterClass({\n    type: 'object',\n    typename: null,\n    ...propsFilterToAst(props),\n  });\n};\n\nexport type TextSearchOptions = {\n  // TODO(dmaretskyi): Hybrid search.\n  type?: 'full-text' | 'vector';\n};\n\n/**\n * Full-text or vector search.\n */\nexport const text = (\n  // TODO(dmaretskyi): Consider passing a vector here, but really the embedding should be done on the query-executor side.\n  text: string,\n  options?: TextSearchOptions,\n): Any => {\n  return new FilterClass({\n    type: 'text-search',\n    text,\n    searchKind: options?.type,\n  });\n};\n\n/**\n * Filter by foreign keys.\n */\nexport const foreignKeys = <S extends Schema.Schema.All>(\n  schema: S | string,\n  keys: ForeignKey[],\n): Filter<Schema.Schema.Type<S>> => {\n  const dxn = getTypeDXNFromSpecifier(schema);\n  return new FilterClass({\n    type: 'object',\n    typename: dxn.toString(),\n    props: {},\n    foreignKeys: keys,\n  });\n};\n\n/**\n * Predicate for property to be equal to the provided value.\n */\nexport const eq = <T>(value: T): Filter<T | undefined> => {\n  if (!Ref.isRef(value) && typeof value === 'object' && value !== null) {\n    throw new TypeError('Cannot use object as a value for eq filter');\n  }\n\n  return new FilterClass({\n    type: 'compare',\n    operator: 'eq',\n    value: Ref.isRef(value) ? value.noInline().encode() : value,\n  });\n};\n\n/**\n * Predicate for property to be not equal to the provided value.\n */\nexport const neq = <T>(value: T): Filter<T | undefined> => {\n  return new FilterClass({\n    type: 'compare',\n    operator: 'neq',\n    value,\n  });\n};\n\n/**\n * Predicate for property to be greater than the provided value.\n */\nexport const gt = <T>(value: T): Filter<T | undefined> => {\n  return new FilterClass({\n    type: 'compare',\n    operator: 'gt',\n    value,\n  });\n};\n\n/**\n * Predicate for property to be greater than or equal to the provided value.\n */\nexport const gte = <T>(value: T): Filter<T | undefined> => {\n  return new FilterClass({\n    type: 'compare',\n    operator: 'gte',\n    value,\n  });\n};\n\n/**\n * Predicate for property to be less than the provided value.\n */\nexport const lt = <T>(value: T): Filter<T | undefined> => {\n  return new FilterClass({\n    type: 'compare',\n    operator: 'lt',\n    value,\n  });\n};\n\n/**\n * Predicate for property to be less than or equal to the provided value.\n */\nexport const lte = <T>(value: T): Filter<T | undefined> => {\n  return new FilterClass({\n    type: 'compare',\n    operator: 'lte',\n    value,\n  });\n};\n\n/**\n * Predicate for property to be in the provided array.\n * @param values - Values to check against.\n */\nconst in$ = <T>(...values: T[]): Filter<T | undefined> => {\n  return new FilterClass({\n    type: 'in',\n    values,\n  });\n};\nexport { in$ as in };\n\n/**\n * Predicate for an array property to contain the provided value.\n * @param value - Value to check against.\n */\nexport const contains = <T>(value: T): Filter<readonly T[] | undefined> => {\n  return new FilterClass({\n    type: 'contains',\n    value,\n  });\n};\n\n/**\n * Predicate for property to be in the provided range.\n * @param from - Start of the range (inclusive).\n * @param to - End of the range (exclusive).\n */\nexport const between = <T>(from: T, to: T): Filter<unknown> => {\n  return new FilterClass({\n    type: 'range',\n    from,\n    to,\n  });\n};\n\n/**\n * Negate the filter.\n */\nexport const not = <F extends Any>(filter: F): Filter<Type<F>> => {\n  return new FilterClass({\n    type: 'not',\n    filter: filter.ast,\n  });\n};\n\n/**\n * Combine filters with a logical AND.\n */\nexport const and = <Filters extends readonly Any[]>(...filters: Filters): Filter<Type<Filters[number]>> => {\n  return new FilterClass({\n    type: 'and',\n    filters: filters.map((f) => f.ast),\n  });\n};\n\n/**\n * Combine filters with a logical OR.\n */\nexport const or = <Filters extends readonly Any[]>(...filters: Filters): Filter<Type<Filters[number]>> => {\n  return new FilterClass({\n    type: 'or',\n    filters: filters.map((f) => f.ast),\n  });\n};\n\n// TODO(dmaretskyi): Add `Filter.match` to support pattern matching on string props.\n\nconst propsFilterToAst = (predicates: Props<any>): Pick<QueryAST.FilterObject, 'id' | 'props'> => {\n  let idFilter: readonly ObjectId[] | undefined;\n  if ('id' in predicates) {\n    assertArgument(\n      typeof predicates.id === 'string' || Array.isArray(predicates.id),\n      'predicates.id',\n      'invalid id filter',\n    );\n    idFilter = typeof predicates.id === 'string' ? [predicates.id] : predicates.id;\n    Schema.Array(ObjectId).pipe(Schema.validateSync)(idFilter);\n  }\n\n  return {\n    id: idFilter,\n    props: Object.fromEntries(\n      Object.entries(predicates)\n        .filter(([prop, _value]) => prop !== 'id')\n        .map(([prop, predicate]) => [prop, processPredicate(predicate)]),\n    ) as Record<string, QueryAST.Filter>,\n  };\n};\n\nconst processPredicate = (predicate: any): QueryAST.Filter => {\n  return Match.value(predicate).pipe(\n    Match.withReturnType<QueryAST.Filter>(),\n    Match.when(is, (predicate) => predicate.ast),\n    // TODO(wittjosiah): Add support for array predicates.\n    Match.when(Array.isArray, (_predicate) => {\n      throw new Error('Array predicates are not yet supported.');\n    }),\n    Match.when(\n      (predicate: any) => !Ref.isRef(predicate) && typeof predicate === 'object' && predicate !== null,\n      (predicate) => {\n        const nestedProps = Object.fromEntries(\n          Object.entries(predicate).map(([key, value]) => [key, processPredicate(value)]),\n        );\n\n        return {\n          type: 'object',\n          typename: null,\n          props: nestedProps,\n        };\n      },\n    ),\n    Match.orElse((value) => eq(value).ast),\n  );\n};\n"],
+  "mappings": "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",
+  "names": ["Match", "Schema", "assertArgument", "DXN", "ObjectId", "FilterClass", "variance", "ast", "is", "value", "fromAst", "everything", "type", "typename", "props", "nothing", "filter", "id", "ids", "assertArgument", "every", "ObjectId", "isValid", "length", "schema", "dxn", "getTypeDXNFromSpecifier", "toString", "propsFilterToAst", "startsWith", "DXN", "fromTypename", "typeDXN", "tag", "text", "options", "searchKind", "foreignKeys", "keys", "eq", "isRef", "TypeError", "operator", "noInline", "encode", "neq", "gt", "gte", "lt", "lte", "in$", "values", "contains", "value", "FilterClass", "type", "between", "from", "to", "not", "filter", "ast", "and", "filters", "map", "f", "or", "propsFilterToAst", "predicates", "idFilter", "assertArgument", "id", "Array", "isArray", "Schema", "ObjectId", "pipe", "validateSync", "props", "Object", "fromEntries", "entries", "prop", "_value", "predicate", "processPredicate", "withReturnType", "when", "is", "_predicate", "Error", "isRef", "nestedProps", "key", "typename", "orElse", "eq"]
+}

package/dist/lib/node-esm/chunk-UKGVOINP.mjs

@@ -0,0 +1,9 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+
+// src/QueryResult.ts
+var QueryResult_exports = {};
+
+export {
+  QueryResult_exports
+};
+//# sourceMappingURL=chunk-UKGVOINP.mjs.map

package/dist/lib/node-esm/chunk-UKGVOINP.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/QueryResult.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { type CleanupFn } from '@dxos/async';\n\nimport type * as Entity from './Entity';\n\n/**\n * Individual query result entry.\n */\nexport type Entry<T> = {\n  id: string;\n\n  /**\n   * May not be present for remote results.\n   */\n  result?: T;\n\n  match?: {\n    // TODO(dmaretskyi): text positional info.\n\n    /**\n     * Higher means better match.\n     */\n    rank: number;\n  };\n\n  /**\n   * Query resolution metadata.\n   */\n  // TODO(dmaretskyi): Rename to meta?\n  resolution?: {\n    // TODO(dmaretskyi): Make this more generic.\n    source: 'remote' | 'local' | 'index';\n\n    /**\n     * Query resolution time in milliseconds.\n     */\n    time: number;\n  };\n};\n\n/**\n * Invidual query result entry for a database Entity.\n */\nexport type EntityEntry<T extends Entity.Unknown = Entity.Unknown> = Entry<T>;\n\nexport type RunOptions = {\n  timeout?: number;\n};\n\nexport type SubscriptionOptions = {\n  /**\n   * Fire the callback immediately.\n   */\n  fire?: boolean;\n};\n\n// TODO(burdon): Should T be constrained to Entity.Any?\nexport interface QueryResult<T> {\n  /**\n   * Currently available results along with their match metadata.\n   */\n  readonly entries: Entry<T>[];\n\n  /**\n   * Currently available results.\n   */\n  readonly results: T[];\n\n  /**\n   * Returns all known results.\n   */\n  run(opts?: RunOptions): Promise<T[]>;\n\n  /**\n   * Returns all known results along with their match metadata.\n   */\n  runEntries(opts?: RunOptions): Promise<Entry<T>[]>;\n\n  /**\n   * Returns currently available results synchronously.\n   */\n  runSync(): T[];\n\n  /**\n   * Returns currently available results synchronously along with their match metadata.\n   */\n  runSyncEntries(): Entry<T>[];\n\n  /**\n   * Returns first result.\n   */\n  first(opts?: RunOptions): Promise<T>;\n\n  /**\n   * Returns first result if there is one.\n   */\n  firstOrUndefined(opts?: RunOptions): Promise<T | undefined>;\n\n  /**\n   * Subscribes to changes in query results.\n   */\n  subscribe(callback?: (query: QueryResult<T>) => void, opts?: SubscriptionOptions): CleanupFn;\n}\n"],
+  "mappings": ";;;AAAA;",
+  "names": []
+}

package/dist/lib/node-esm/chunk-W6QIEBTQ.mjs

@@ -0,0 +1,403 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  createAnnotationHelper
+} from "./chunk-XHJRMQZD.mjs";
+
+// src/internal/formats/types.ts
+import * as Function from "effect/Function";
+import * as Option from "effect/Option";
+import * as SchemaAST from "effect/SchemaAST";
+var TypeEnum = /* @__PURE__ */ (function(TypeEnum2) {
+  TypeEnum2["Array"] = "array";
+  TypeEnum2["Object"] = "object";
+  TypeEnum2["String"] = "string";
+  TypeEnum2["Number"] = "number";
+  TypeEnum2["Boolean"] = "boolean";
+  TypeEnum2["Ref"] = "ref";
+  return TypeEnum2;
+})({});
+var getTypeEnum = (property) => {
+  switch (property.type) {
+    case "array":
+      return "array";
+    case "object":
+      return "object";
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    default:
+      return void 0;
+  }
+};
+var FormatAnnotationId = Symbol.for("@dxos/schema/annotation/Format");
+var FormatAnnotation = createAnnotationHelper(FormatAnnotationId);
+var getFormatAnnotation = (node) => Function.pipe(SchemaAST.getAnnotation(FormatAnnotationId)(node), Option.getOrUndefined);
+var TypeFormat = /* @__PURE__ */ (function(TypeFormat2) {
+  TypeFormat2["None"] = "none";
+  TypeFormat2["String"] = "string";
+  TypeFormat2["Number"] = "number";
+  TypeFormat2["Boolean"] = "boolean";
+  TypeFormat2["Ref"] = "ref";
+  TypeFormat2["DID"] = "did";
+  TypeFormat2["DXN"] = "dxn";
+  TypeFormat2["Email"] = "email";
+  TypeFormat2["Formula"] = "formula";
+  TypeFormat2["Hostname"] = "hostname";
+  TypeFormat2["JSON"] = "json";
+  TypeFormat2["Markdown"] = "markdown";
+  TypeFormat2["Regex"] = "regex";
+  TypeFormat2["SingleSelect"] = "single-select";
+  TypeFormat2["Text"] = "text";
+  TypeFormat2["MultiSelect"] = "multi-select";
+  TypeFormat2["URL"] = "url";
+  TypeFormat2["UUID"] = "uuid";
+  TypeFormat2["Currency"] = "currency";
+  TypeFormat2["Integer"] = "integer";
+  TypeFormat2["Percent"] = "percent";
+  TypeFormat2["Timestamp"] = "timestamp";
+  TypeFormat2["DateTime"] = "date-time";
+  TypeFormat2["Date"] = "date";
+  TypeFormat2["Time"] = "time";
+  TypeFormat2["Duration"] = "duration";
+  TypeFormat2["GeoPoint"] = "lnglat";
+  return TypeFormat2;
+})({});
+var FormatEnums = Object.values(TypeFormat).sort();
+var PropertyKind = {
+  type: TypeEnum,
+  format: TypeFormat
+};
+var typeToFormat = {
+  ["string"]: "string",
+  ["number"]: "number",
+  ["boolean"]: "boolean"
+};
+var formatToType = {
+  ["none"]: void 0,
+  ["string"]: "string",
+  ["number"]: "number",
+  ["boolean"]: "boolean",
+  ["ref"]: "ref",
+  ["did"]: "string",
+  ["dxn"]: "string",
+  ["email"]: "string",
+  ["formula"]: "string",
+  ["hostname"]: "string",
+  ["json"]: "string",
+  ["markdown"]: "string",
+  ["regex"]: "string",
+  ["url"]: "string",
+  ["uuid"]: "string",
+  ["single-select"]: "string",
+  ["text"]: "string",
+  ["multi-select"]: "object",
+  ["date"]: "string",
+  ["date-time"]: "string",
+  ["duration"]: "string",
+  ["time"]: "string",
+  ["currency"]: "number",
+  ["integer"]: "number",
+  ["percent"]: "number",
+  ["timestamp"]: "number",
+  ["lnglat"]: "array"
+};
+var OptionsAnnotationId = Symbol.for("@dxos/schema/annotation/Options");
+var OptionsAnnotation = createAnnotationHelper(OptionsAnnotationId);
+var getOptionsAnnotation = (node) => Function.pipe(SchemaAST.getAnnotation(OptionsAnnotationId)(node), Option.getOrUndefined);
+
+// src/internal/formats/number.ts
+import * as Schema from "effect/Schema";
+var encodeMultipleOf = (divisor) => 1 / Math.pow(10, divisor);
+var encodeMultiple = (divisor) => (self) => divisor === void 0 || divisor === 0 ? self : self.pipe(Schema.multipleOf(encodeMultipleOf(divisor)));
+var DecimalPrecision = Schema.transform(Schema.Number, Schema.Number, {
+  strict: true,
+  encode: (value) => encodeMultipleOf(value),
+  decode: (value) => Math.log10(1 / value)
+}).annotations({
+  title: "Number of digits"
+});
+var CurrencyAnnotationId = Symbol.for("@dxos/schema/annotation/Currency");
+var Currency = ({ decimals, code } = {
+  decimals: 2
+}) => Schema.Number.pipe(encodeMultiple(decimals), FormatAnnotation.set(TypeFormat.Currency), Schema.annotations({
+  title: "Currency",
+  description: "Currency value",
+  ...code ? {
+    [CurrencyAnnotationId]: code.toUpperCase()
+  } : {}
+}));
+var Integer = () => Schema.Number.pipe(Schema.int(), FormatAnnotation.set(TypeFormat.Integer), Schema.annotations({
+  title: "Integer",
+  description: "Integer value"
+}));
+var Percent = ({ decimals } = {
+  decimals: 2
+}) => Schema.Number.pipe(encodeMultiple(decimals), FormatAnnotation.set(TypeFormat.Percent), Schema.annotations({
+  title: "Percent",
+  description: "Percentage value"
+}));
+var Timestamp = Schema.Number.pipe(FormatAnnotation.set(TypeFormat.Timestamp), Schema.annotations({
+  title: "Timestamp",
+  description: "Unix timestamp"
+}));
+
+// src/internal/formats/object.ts
+import * as Schema2 from "effect/Schema";
+import { clamp as clamp2 } from "@dxos/util";
+var GeoPoint = Schema2.Tuple(Schema2.Number.pipe(Schema2.annotations({
+  title: "Longitude"
+}), Schema2.clamp(-180, 180), Schema2.multipleOf(1e-6)), Schema2.Number.pipe(Schema2.annotations({
+  title: "Latitude"
+}), Schema2.clamp(-90, 90), Schema2.multipleOf(1e-6)), Schema2.optionalElement(Schema2.Number).annotations({
+  title: "Height ASL (m)"
+})).pipe(FormatAnnotation.set(TypeFormat.GeoPoint), Schema2.annotations({
+  title: "GeoPoint",
+  description: "GeoJSON Position"
+}));
+(function(GeoLocation2) {
+  GeoLocation2.toGeoPoint = ({ longitude, latitude, height }) => {
+    const clampedLongitude = clamp2(longitude, -180, 180);
+    const clampedLatitude = clamp2(latitude, -90, 90);
+    return height !== void 0 ? [
+      clampedLongitude,
+      clampedLatitude,
+      height
+    ] : [
+      clampedLongitude,
+      clampedLatitude
+    ];
+  };
+  GeoLocation2.fromGeoPoint = (geoPoint) => {
+    if (!geoPoint) {
+      return {
+        longitude: 0,
+        latitude: 0
+      };
+    }
+    const result = {
+      longitude: geoPoint[0],
+      latitude: geoPoint[1]
+    };
+    if (geoPoint[2] !== void 0) {
+      result.height = geoPoint[2];
+    }
+    return result;
+  };
+})(GeoLocation || (GeoLocation = {}));
+var GeoLocation;
+
+// src/internal/formats/string.ts
+import * as Schema3 from "effect/Schema";
+import * as SchemaAST2 from "effect/SchemaAST";
+var Email = Schema3.String.pipe(Schema3.pattern(/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/), FormatAnnotation.set(TypeFormat.Email), Schema3.annotations({
+  title: "Email",
+  description: "Email address"
+}));
+var Formula = Schema3.String.pipe(FormatAnnotation.set(TypeFormat.Formula));
+var Hostname = Schema3.String.pipe(FormatAnnotation.set(TypeFormat.Hostname));
+var JSON = Schema3.String.pipe(FormatAnnotation.set(TypeFormat.JSON));
+var Markdown = Schema3.String.pipe(FormatAnnotation.set(TypeFormat.Markdown));
+var Regex = Schema3.String.pipe(FormatAnnotation.set(TypeFormat.Regex));
+var Text = Schema3.String.pipe(FormatAnnotation.set(TypeFormat.Text));
+var URL = Schema3.String.pipe(Schema3.pattern(/^(\w+?:\/\/)?([\da-z.-]+)\.([a-z.]{2,6})([/\w .-]*)*\/?$/i), FormatAnnotation.set(TypeFormat.URL), Schema3.annotations({
+  title: "URL",
+  description: "URL"
+}));
+var UUID2 = Schema3.UUID.pipe(FormatAnnotation.set(TypeFormat.UUID), Schema3.annotations({
+  [SchemaAST2.ExamplesAnnotationId]: [
+    "3e4666bf-d5e5-4aa7-b8ce-cefe41c7568a"
+  ]
+}));
+
+// src/internal/formats/format.ts
+import * as Schema5 from "effect/Schema";
+import * as Keys from "@dxos/keys";
+
+// src/internal/formats/date.ts
+import * as Schema4 from "effect/Schema";
+import * as SchemaAST3 from "effect/SchemaAST";
+var SimpleDate = Schema4.Struct({
+  year: Schema4.Number.pipe(Schema4.between(1900, 9999)),
+  month: Schema4.Number.pipe(Schema4.between(1, 12)),
+  day: Schema4.Number.pipe(Schema4.between(1, 31))
+});
+var SimpleTime = Schema4.Struct({
+  hours: Schema4.Number.pipe(Schema4.between(0, 23)),
+  minutes: Schema4.Number.pipe(Schema4.between(0, 59)),
+  seconds: Schema4.Number.pipe(Schema4.between(0, 59))
+});
+var SimpleDateTime = Schema4.extend(SimpleDate, SimpleTime);
+var DateOnly = (
+  /* Schema.transformOrFail(Schema.String, SimpleDate, {
+    strict: true,
+    decode: (str, _, ast) => {
+      if (!isValidDateFormat(str)) {
+        return ParseResult.fail(new ParseResult.Type(ast, str, 'Expected YYYY-MM-DD format'));
+      }
+      if (!isValidDate(str)) {
+        return ParseResult.fail(new ParseResult.Type(ast, str, 'Invalid date'));
+      }
+  
+      const [year, month, day] = str.split('-').map(Number);
+      return ParseResult.succeed({ year, month, day });
+    },
+    encode: (date) => {
+      return ParseResult.succeed(
+        [
+          date.year.toString().padStart(4, '0'),
+          date.month.toString().padStart(2, '0'),
+          date.day.toString().padStart(2, '0'),
+        ].join('-'),
+      );
+    },
+  }) */
+  Schema4.String.pipe(FormatAnnotation.set(TypeFormat.Date), Schema4.annotations({
+    title: "Date",
+    description: "Valid date in ISO format"
+  }))
+);
+var TimeOnly = (
+  /* Schema.transformOrFail(Schema.String, SimpleTime, {
+    strict: true,
+    decode: (str, _, ast) => {
+      if (!isValidTimeFormat(str)) {
+        return ParseResult.fail(new ParseResult.Type(ast, str, 'Expected HH:mm:ss format'));
+      }
+  
+      const [hours, minutes, seconds] = str.split(':').map(Number);
+      return ParseResult.succeed({ hours, minutes, seconds });
+    },
+    encode: (time) => {
+      return ParseResult.succeed(
+        [
+          time.hours.toString().padStart(2, '0'),
+          time.minutes.toString().padStart(2, '0'),
+          time.seconds.toString().padStart(2, '0'),
+        ].join(':'),
+      );
+    },
+  }) */
+  Schema4.String.pipe(FormatAnnotation.set(TypeFormat.Time), Schema4.annotations({
+    title: "Time",
+    description: "Valid time in ISO format"
+  }))
+);
+var DateTime = (
+  /* Schema.transformOrFail(Schema.String, SimpleDateTime, {
+    strict: false,
+    decode: (str, _, ast) => {
+      const [date, time] = str.split('T');
+      if (!isValidDateFormat(date)) {
+        return ParseResult.fail(new ParseResult.Type(ast, date, 'Expected YYYY-MM-DD format'));
+      }
+      if (!isValidDate(date)) {
+        return ParseResult.fail(new ParseResult.Type(ast, date, 'Invalid date'));
+      }
+      if (!isValidTimeFormat(time)) {
+        return ParseResult.fail(new ParseResult.Type(ast, str, 'Expected HH:mm:ss format'));
+      }
+  
+      const [year, month, day] = date.split('-').map(Number);
+      const [hours, minutes, seconds] = time.split(':').map(Number);
+      return ParseResult.succeed({ year, month, day, hours, minutes, seconds });
+    },
+    encode: (datetime) => {
+      return ParseResult.succeed(
+        [
+          [
+            datetime.year.toString().padStart(4, '0'),
+            datetime.month.toString().padStart(2, '0'),
+            datetime.day.toString().padStart(2, '0'),
+          ].join('-'),
+          [
+            datetime.hours.toString().padStart(2, '0'),
+            datetime.minutes.toString().padStart(2, '0'),
+            datetime.seconds.toString().padStart(2, '0'),
+          ].join(':'),
+        ].join('T'),
+      );
+    },
+  }) */
+  Schema4.String.pipe(FormatAnnotation.set(TypeFormat.DateTime), Schema4.annotations({
+    title: "DateTime",
+    description: "Valid date and time in ISO format"
+  }))
+);
+var Duration = Schema4.String.pipe(FormatAnnotation.set(TypeFormat.Duration), Schema4.annotations({
+  title: "Duration",
+  description: "Duration in ISO 8601 format",
+  [SchemaAST3.ExamplesAnnotationId]: [
+    "1h",
+    "3D"
+  ]
+}));
+
+// src/internal/formats/format.ts
+(function(Format2) {
+  Format2.TypeFormat = TypeFormat;
+  Format2.DXN = Keys.DXN.Schema;
+  Format2.Email = Email;
+  Format2.Formula = Formula;
+  Format2.Hostname = Hostname;
+  Format2.JSON = JSON;
+  Format2.Markdown = Markdown;
+  Format2.Regex = Regex;
+  Format2.URL = URL;
+  Format2.UUID = Schema5.UUID;
+  Format2.Currency = Currency;
+  Format2.Integer = Integer;
+  Format2.Percent = Percent;
+  Format2.Timestamp = Timestamp;
+  Format2.Date = DateOnly;
+  Format2.DateTime = DateTime;
+  Format2.Duration = Duration;
+  Format2.Time = TimeOnly;
+  Format2.GeoPoint = GeoPoint;
+})(Format || (Format = {}));
+var Format;
+
+// src/internal/formats/select.ts
+import * as Schema6 from "effect/Schema";
+var SelectOption = Schema6.Struct({
+  /** Stable identifier for the option. */
+  id: Schema6.NonEmptyString,
+  title: Schema6.String,
+  /** Color palette used for visual styling. */
+  color: Schema6.String
+}).pipe(Schema6.mutable);
+
+export {
+  TypeEnum,
+  getTypeEnum,
+  FormatAnnotationId,
+  FormatAnnotation,
+  getFormatAnnotation,
+  TypeFormat,
+  FormatEnums,
+  PropertyKind,
+  typeToFormat,
+  formatToType,
+  OptionsAnnotationId,
+  OptionsAnnotation,
+  getOptionsAnnotation,
+  DecimalPrecision,
+  CurrencyAnnotationId,
+  Currency,
+  GeoPoint,
+  GeoLocation,
+  Email,
+  Formula,
+  Hostname,
+  JSON,
+  Markdown,
+  Regex,
+  Text,
+  URL,
+  UUID2 as UUID,
+  Format,
+  SelectOption
+};
+//# sourceMappingURL=chunk-W6QIEBTQ.mjs.map

package/dist/lib/node-esm/chunk-W6QIEBTQ.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/formats/types.ts", "../../../src/internal/formats/number.ts", "../../../src/internal/formats/object.ts", "../../../src/internal/formats/string.ts", "../../../src/internal/formats/format.ts", "../../../src/internal/formats/date.ts", "../../../src/internal/formats/select.ts"],
+  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nimport * as Function from 'effect/Function';\nimport type * as JSONSchema from 'effect/JSONSchema';\nimport * as Option from 'effect/Option';\nimport * as SchemaAST from 'effect/SchemaAST';\n\nimport { createAnnotationHelper } from '../annotations';\nimport { type JsonSchemaType } from '../json-schema';\n\n// TODO(burdon): Rename PropertyType.\nexport type ScalarType =\n  | JSONSchema.JsonSchema7Object\n  | JSONSchema.JsonSchema7String\n  | JSONSchema.JsonSchema7Number\n  | JSONSchema.JsonSchema7Boolean\n  | JSONSchema.JsonSchema7Ref;\n\n// TODO(burdon): Rename ValueType and change to disciminated union.\n// export type ValueType = 'array' | 'object' | 'string' | 'number' | 'boolean' | 'ref';\nexport enum TypeEnum {\n  Array = 'array', // TODO(burdon): Remove?\n  Object = 'object',\n  String = 'string',\n  Number = 'number',\n  Boolean = 'boolean',\n  Ref = 'ref',\n}\n\n// TODO(burdon): Ref?\nexport const getTypeEnum = (property: JsonSchemaType): TypeEnum | undefined => {\n  switch (property.type) {\n    case 'array':\n      return TypeEnum.Array;\n    case 'object':\n      return TypeEnum.Object;\n    case 'string':\n      return TypeEnum.String;\n    case 'number':\n      return TypeEnum.Number;\n    case 'boolean':\n      return TypeEnum.Boolean;\n    default:\n      return undefined;\n  }\n};\n\n/**\n * https://json-schema.org/understanding-json-schema/reference/schema\n * https://json-schema.org/understanding-json-schema/reference/string#built-in-formats\n */\nexport const FormatAnnotationId = Symbol.for('@dxos/schema/annotation/Format');\n\nexport const FormatAnnotation = createAnnotationHelper<TypeFormat>(FormatAnnotationId);\n\n/** @deprecated */\nexport const getFormatAnnotation = (node: SchemaAST.AST): TypeFormat | undefined =>\n  Function.pipe(SchemaAST.getAnnotation<TypeFormat>(FormatAnnotationId)(node), Option.getOrUndefined);\n\n// TODO(burdon): Rename Format; Change to discriminated union?\nexport enum TypeFormat {\n  None = 'none',\n\n  //\n  // Scalar\n  //\n\n  String = 'string',\n  Number = 'number',\n  Boolean = 'boolean',\n  Ref = 'ref',\n\n  //\n  // { type: 'string' }\n  //\n\n  DID = 'did', // Users, etc.\n  DXN = 'dxn',\n  Email = 'email',\n  Formula = 'formula', // Spreadsheet formula.\n  Hostname = 'hostname',\n  JSON = 'json',\n  Markdown = 'markdown',\n  Regex = 'regex',\n  SingleSelect = 'single-select',\n  Text = 'text',\n  MultiSelect = 'multi-select',\n  URL = 'url',\n  UUID = 'uuid',\n\n  //\n  // { type: 'number' }\n  //\n\n  Currency = 'currency',\n  Integer = 'integer',\n  Percent = 'percent',\n  Timestamp = 'timestamp',\n\n  //\n  // { type: 'date' }\n  //\n\n  DateTime = 'date-time',\n  Date = 'date',\n  Time = 'time',\n  Duration = 'duration',\n\n  //\n  // { type: 'object' }\n  //\n\n  GeoPoint = 'lnglat',\n}\n\nexport const FormatEnums = Object.values(TypeFormat).sort();\n\nexport const PropertyKind = {\n  type: TypeEnum,\n  format: TypeFormat,\n};\n\n/**\n * Default formats\n */\nexport const typeToFormat: Partial<Record<TypeEnum, TypeFormat>> = {\n  [TypeEnum.String]: TypeFormat.String,\n  [TypeEnum.Number]: TypeFormat.Number,\n  [TypeEnum.Boolean]: TypeFormat.Boolean,\n};\n\n/**\n * Map of format to type.\n */\nexport const formatToType: Record<TypeFormat, TypeEnum> = {\n  [TypeFormat.None]: undefined as any,\n  [TypeFormat.String]: TypeEnum.String,\n  [TypeFormat.Number]: TypeEnum.Number,\n  [TypeFormat.Boolean]: TypeEnum.Boolean,\n  [TypeFormat.Ref]: TypeEnum.Ref,\n\n  // Strings\n  [TypeFormat.DID]: TypeEnum.String,\n  [TypeFormat.DXN]: TypeEnum.String,\n  [TypeFormat.Email]: TypeEnum.String,\n  [TypeFormat.Formula]: TypeEnum.String,\n  [TypeFormat.Hostname]: TypeEnum.String,\n  [TypeFormat.JSON]: TypeEnum.String,\n  [TypeFormat.Markdown]: TypeEnum.String,\n  [TypeFormat.Regex]: TypeEnum.String,\n  [TypeFormat.URL]: TypeEnum.String,\n  [TypeFormat.UUID]: TypeEnum.String,\n  [TypeFormat.SingleSelect]: TypeEnum.String,\n  [TypeFormat.Text]: TypeEnum.String,\n  [TypeFormat.MultiSelect]: TypeEnum.Object,\n\n  // Dates\n  [TypeFormat.Date]: TypeEnum.String,\n  [TypeFormat.DateTime]: TypeEnum.String,\n  [TypeFormat.Duration]: TypeEnum.String,\n  [TypeFormat.Time]: TypeEnum.String,\n\n  // Numbers\n  [TypeFormat.Currency]: TypeEnum.Number,\n  [TypeFormat.Integer]: TypeEnum.Number,\n  [TypeFormat.Percent]: TypeEnum.Number,\n  [TypeFormat.Timestamp]: TypeEnum.Number,\n\n  // Objects\n  [TypeFormat.GeoPoint]: TypeEnum.Array,\n};\n\n/**\n * Allowed value options for select.\n */\nexport const OptionsAnnotationId = Symbol.for('@dxos/schema/annotation/Options');\n\n// TODO(wittjosiah): Reconcile with `SelectOption`.\nexport type Options = string | number;\nexport const OptionsAnnotation = createAnnotationHelper<Options[]>(OptionsAnnotationId);\n\n/** @deprecated */\nexport const getOptionsAnnotation = (node: SchemaAST.AST): Options[] | undefined =>\n  Function.pipe(SchemaAST.getAnnotation<Options[]>(OptionsAnnotationId)(node), Option.getOrUndefined);\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport { FormatAnnotation, TypeFormat } from './types';\n\nconst encodeMultipleOf = (divisor: number) => 1 / Math.pow(10, divisor);\n\nconst encodeMultiple =\n  <A extends number>(divisor?: number) =>\n  <I, R>(self: Schema.Schema<A, I, R>) =>\n    divisor === undefined || divisor === 0 ? self : self.pipe(Schema.multipleOf(encodeMultipleOf(divisor)));\n\n/**\n * Convert number of digits to multipleOf annotation.\n */\nexport const DecimalPrecision = Schema.transform(Schema.Number, Schema.Number, {\n  strict: true,\n  encode: (value) => encodeMultipleOf(value),\n  decode: (value) => Math.log10(1 / value),\n}).annotations({\n  title: 'Number of digits',\n});\n\nexport const CurrencyAnnotationId = Symbol.for('@dxos/schema/annotation/Currency');\n\nexport type CurrencyAnnotation = {\n  decimals?: number;\n  code?: string;\n};\n\n/**\n * ISO 4217 currency code.\n */\nexport const Currency = ({ decimals, code }: CurrencyAnnotation = { decimals: 2 }) =>\n  Schema.Number.pipe(\n    encodeMultiple(decimals),\n    FormatAnnotation.set(TypeFormat.Currency),\n    Schema.annotations({\n      title: 'Currency',\n      description: 'Currency value',\n      ...(code ? { [CurrencyAnnotationId]: code.toUpperCase() } : {}),\n    }),\n  );\n\nexport type PercentAnnotation = {\n  decimals?: number;\n};\n\n/**\n * Integer.\n */\nexport const Integer = () =>\n  Schema.Number.pipe(\n    Schema.int(),\n    FormatAnnotation.set(TypeFormat.Integer),\n    Schema.annotations({\n      title: 'Integer',\n      description: 'Integer value',\n    }),\n  );\n\n/**\n * Percent.\n */\n// TODO(burdon): Define min/max (e.g., 0, 1).\nexport const Percent = ({ decimals }: PercentAnnotation = { decimals: 2 }) =>\n  Schema.Number.pipe(\n    encodeMultiple(decimals),\n    FormatAnnotation.set(TypeFormat.Percent),\n    Schema.annotations({\n      title: 'Percent',\n      description: 'Percentage value',\n    }),\n  );\n\n/**\n * Unix timestamp.\n * https://en.wikipedia.org/wiki/Unix_time\n */\nexport const Timestamp = Schema.Number.pipe(\n  FormatAnnotation.set(TypeFormat.Timestamp),\n  Schema.annotations({\n    title: 'Timestamp',\n    description: 'Unix timestamp',\n  }),\n);\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport { clamp } from '@dxos/util';\n\nimport { FormatAnnotation, TypeFormat } from './types';\n\n/**\n * GeoJSON Format\n * https://datatracker.ietf.org/doc/html/rfc7946\n * https://datatracker.ietf.org/doc/html/rfc7946#section-3.1.1\n * https://en.wikipedia.org/wiki/Geographic_coordinate_system\n * https://geojson.org\n * {\n *   \"type\": \"Point\",\n *   \"coordinates\": [0, 51.47] // [longitude, latitude]\n * }\n * Note: optional third element for altitude.\n */\nexport const GeoPoint = Schema.Tuple(\n  Schema.Number.pipe(Schema.annotations({ title: 'Longitude' }), Schema.clamp(-180, 180), Schema.multipleOf(0.000001)),\n  Schema.Number.pipe(Schema.annotations({ title: 'Latitude' }), Schema.clamp(-90, 90), Schema.multipleOf(0.000001)),\n  Schema.optionalElement(Schema.Number).annotations({\n    title: 'Height ASL (m)',\n  }),\n).pipe(\n  FormatAnnotation.set(TypeFormat.GeoPoint),\n  Schema.annotations({\n    title: 'GeoPoint',\n    description: 'GeoJSON Position',\n  }),\n);\n\nexport type GeoPoint = Schema.Schema.Type<typeof GeoPoint>;\n\nexport type GeoLocation = {\n  longitude: number;\n  latitude: number;\n  height?: number;\n};\n\n/**\n * Geolocation utilities for working with GeoPoint format.\n */\nexport namespace GeoLocation {\n  /**\n   * Convert latitude and longitude to GeoPoint (GeoJSON format [longitude, latitude, height?]).\n   * Clamps values to valid ranges: latitude [-90, 90], longitude [-180, 180].\n   */\n  export const toGeoPoint = ({ longitude, latitude, height }: GeoLocation): GeoPoint => {\n    // TODO(ZaymonFC): Use schema validation instead of doing this manually.\n    const clampedLongitude = clamp(longitude, -180, 180);\n    const clampedLatitude = clamp(latitude, -90, 90);\n    return height !== undefined ? [clampedLongitude, clampedLatitude, height] : [clampedLongitude, clampedLatitude];\n  };\n\n  /**\n   * Extract latitude and longitude from GeoPoint (GeoJSON format [longitude, latitude, height?]).\n   */\n  export const fromGeoPoint = (geoPoint: GeoPoint | undefined): GeoLocation => {\n    if (!geoPoint) {\n      return { longitude: 0, latitude: 0 };\n    }\n\n    const result: GeoLocation = {\n      longitude: geoPoint[0],\n      latitude: geoPoint[1],\n    };\n\n    // Add height if defined.\n    if (geoPoint[2] !== undefined) {\n      result.height = geoPoint[2];\n    }\n\n    return result;\n  };\n}\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\nimport * as SchemaAST from 'effect/SchemaAST';\n\nimport { FormatAnnotation, TypeFormat } from './types';\n\n/**\n * Email address (RFC 5321)\n * https://datatracker.ietf.org/doc/html/rfc5321#section-4.1.2\n */\nexport const Email = Schema.String.pipe(\n  Schema.pattern(/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$/),\n  FormatAnnotation.set(TypeFormat.Email),\n  Schema.annotations({\n    title: 'Email',\n    description: 'Email address',\n  }),\n);\n\n/**\n *\n */\n// TODO(burdon): Implement.\nexport const Formula = Schema.String.pipe(FormatAnnotation.set(TypeFormat.Formula));\n\n/**\n *\n */\n// TODO(burdon): Implement.\nexport const Hostname = Schema.String.pipe(FormatAnnotation.set(TypeFormat.Hostname));\n\n/**\n *\n */\n// TODO(burdon): Implement.\nexport const JSON = Schema.String.pipe(FormatAnnotation.set(TypeFormat.JSON));\n\n/**\n *\n */\n// TODO(burdon): Implement.\nexport const Markdown = Schema.String.pipe(FormatAnnotation.set(TypeFormat.Markdown));\n\n/**\n * Regex\n * https://json-schema.org/understanding-json-schema/reference/regular_expressions\n * https://ecma-international.org/publications-and-standards/standards/ecma-262\n */\n// TODO(burdon): Implement.\nexport const Regex = Schema.String.pipe(FormatAnnotation.set(TypeFormat.Regex));\n\n/**\n * Multi-line text.\n */\nexport const Text = Schema.String.pipe(FormatAnnotation.set(TypeFormat.Text));\n\n/**\n * https://datatracker.ietf.org/doc/html/rfc3986#section-1.1.3\n */\nexport const URL = Schema.String.pipe(\n  Schema.pattern(/^(\\w+?:\\/\\/)?([\\da-z.-]+)\\.([a-z.]{2,6})([/\\w .-]*)*\\/?$/i),\n  FormatAnnotation.set(TypeFormat.URL),\n  Schema.annotations({\n    title: 'URL',\n    description: 'URL',\n  }),\n);\n\n/**\n * UUID (RFC 4122)\n * https://datatracker.ietf.org/doc/html/rfc4122\n */\nexport const UUID = Schema.UUID.pipe(\n  FormatAnnotation.set(TypeFormat.UUID),\n  Schema.annotations({\n    [SchemaAST.ExamplesAnnotationId]: ['3e4666bf-d5e5-4aa7-b8ce-cefe41c7568a'],\n  }),\n);\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport * as Keys from '@dxos/keys';\n\nimport * as DateUtil from './date';\nimport * as NumberUtil from './number';\nimport * as ObjectUtil from './object';\nimport * as StringUtil from './string';\nimport { TypeFormat as TypeFormat$ } from './types';\n\n// TODO(burdon): Media encoding.\n// - https://json-schema.org/understanding-json-schema/reference/non_json_data\n\n/**\n * Formats.\n * https://json-schema.org/understanding-json-schema/reference/string#built-in-formats\n * NOTE: A JSON Schema validator will ignore any format type that it does not understand.\n */\n// TODO(burdon): Add fields for `examples`, `message`, etc.\nexport namespace Format {\n  export import TypeFormat = TypeFormat$;\n\n  // String\n  export const DXN = Keys.DXN.Schema;\n  export const Email = StringUtil.Email;\n  export const Formula = StringUtil.Formula;\n  export const Hostname = StringUtil.Hostname;\n  export const JSON = StringUtil.JSON;\n  export const Markdown = StringUtil.Markdown;\n  export const Regex = StringUtil.Regex;\n  export const URL = StringUtil.URL;\n  export const UUID = Schema.UUID;\n\n  // Numbers\n  // TODO(burdon): BigInt.\n  export const Currency = NumberUtil.Currency;\n  export const Integer = NumberUtil.Integer;\n  export const Percent = NumberUtil.Percent;\n  export const Timestamp = NumberUtil.Timestamp;\n\n  // Dates and times\n  export const Date = DateUtil.DateOnly;\n  export const DateTime = DateUtil.DateTime;\n  export const Duration = DateUtil.Duration;\n  export const Time = DateUtil.TimeOnly;\n\n  // Objects\n  export const GeoPoint = ObjectUtil.GeoPoint;\n  export type GeoPoint = ObjectUtil.GeoPoint; // TODO(burdon): Export types.\n}\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\nimport * as SchemaAST from 'effect/SchemaAST';\n\nimport { FormatAnnotation, TypeFormat } from './types';\n\n/**\n * Datetime values should be stored as ISO strings or unix numbers (ms) in UTC.\n *\n * NOTE: HyperFormula uses Excel's time format (null date 1900/01/01)\n * It can be configured to use a different parser via `parseDateTime`.\n * https://hyperformula.handsontable.com/guide/date-and-time-handling.html#date-and-time-handling\n * https://github.com/handsontable/hyperformula/blob/master/src/DateTimeHelper.ts\n */\n\n// TODO(burdon): Annotations not present in JSON.\n// TODO(burdon): Timezone.\n// TODO(burdon): Format for timestamp (Unix UTC or ISO 8601)?\n// TODO(burdon): Refs\n//  - https://www.npmjs.com/package/numfmt\n//  - https://date-fns.org/docs/Getting-Started\n//  - https://github.com/date-fns/tz\n\n/**\n * Simple date compatible with HF.\n */\nexport const SimpleDate = Schema.Struct({\n  year: Schema.Number.pipe(Schema.between(1900, 9999)),\n  month: Schema.Number.pipe(Schema.between(1, 12)),\n  day: Schema.Number.pipe(Schema.between(1, 31)),\n});\n\nexport type SimpleDate = Schema.Schema.Type<typeof SimpleDate>;\n\nexport const toSimpleDate = (date: Date): SimpleDate => ({\n  year: date.getUTCFullYear(),\n  month: date.getUTCMonth() + 1,\n  day: date.getUTCDate(),\n});\n\n/**\n * Simple time compatible with HF.\n */\nexport const SimpleTime = Schema.Struct({\n  hours: Schema.Number.pipe(Schema.between(0, 23)),\n  minutes: Schema.Number.pipe(Schema.between(0, 59)),\n  seconds: Schema.Number.pipe(Schema.between(0, 59)),\n});\n\nexport type SimpleTime = Schema.Schema.Type<typeof SimpleTime>;\n\nexport const toSimpleTime = (date: Date): SimpleTime => ({\n  hours: date.getUTCHours(),\n  minutes: date.getUTCSeconds(),\n  seconds: date.getUTCSeconds(),\n});\n\n/**\n * Simple date-time compatible with HF.\n */\nexport const SimpleDateTime = Schema.extend(SimpleDate, SimpleTime);\n\nexport type SimpleDateTime = Schema.Schema.Type<typeof SimpleDateTime>;\n\nexport const toSimpleDateTime = (date: Date): SimpleDateTime => ({\n  ...toSimpleDate(date),\n  ...toSimpleTime(date),\n});\n\n/**\n * https://effect.website/docs/guides/schema/transformations#date-transformations\n */\n\n// TODO(burdon): Consider if transformations should be supported with Automerge.\n\n/**\n * Format: 2018-11-13\n */\nexport const DateOnly = /* Schema.transformOrFail(Schema.String, SimpleDate, {\n  strict: true,\n  decode: (str, _, ast) => {\n    if (!isValidDateFormat(str)) {\n      return ParseResult.fail(new ParseResult.Type(ast, str, 'Expected YYYY-MM-DD format'));\n    }\n    if (!isValidDate(str)) {\n      return ParseResult.fail(new ParseResult.Type(ast, str, 'Invalid date'));\n    }\n\n    const [year, month, day] = str.split('-').map(Number);\n    return ParseResult.succeed({ year, month, day });\n  },\n  encode: (date) => {\n    return ParseResult.succeed(\n      [\n        date.year.toString().padStart(4, '0'),\n        date.month.toString().padStart(2, '0'),\n        date.day.toString().padStart(2, '0'),\n      ].join('-'),\n    );\n  },\n}) */ Schema.String.pipe(\n  FormatAnnotation.set(TypeFormat.Date),\n  Schema.annotations({\n    title: 'Date',\n    description: 'Valid date in ISO format',\n  }),\n);\n\n/**\n * Format: 20:20:39+00:00\n */\nexport const TimeOnly = /* Schema.transformOrFail(Schema.String, SimpleTime, {\n  strict: true,\n  decode: (str, _, ast) => {\n    if (!isValidTimeFormat(str)) {\n      return ParseResult.fail(new ParseResult.Type(ast, str, 'Expected HH:mm:ss format'));\n    }\n\n    const [hours, minutes, seconds] = str.split(':').map(Number);\n    return ParseResult.succeed({ hours, minutes, seconds });\n  },\n  encode: (time) => {\n    return ParseResult.succeed(\n      [\n        time.hours.toString().padStart(2, '0'),\n        time.minutes.toString().padStart(2, '0'),\n        time.seconds.toString().padStart(2, '0'),\n      ].join(':'),\n    );\n  },\n}) */ Schema.String.pipe(\n  FormatAnnotation.set(TypeFormat.Time),\n  Schema.annotations({\n    title: 'Time',\n    description: 'Valid time in ISO format',\n  }),\n);\n\n/**\n * Format: 2018-11-13T20:20:39+00:00\n */\nexport const DateTime = /* Schema.transformOrFail(Schema.String, SimpleDateTime, {\n  strict: false,\n  decode: (str, _, ast) => {\n    const [date, time] = str.split('T');\n    if (!isValidDateFormat(date)) {\n      return ParseResult.fail(new ParseResult.Type(ast, date, 'Expected YYYY-MM-DD format'));\n    }\n    if (!isValidDate(date)) {\n      return ParseResult.fail(new ParseResult.Type(ast, date, 'Invalid date'));\n    }\n    if (!isValidTimeFormat(time)) {\n      return ParseResult.fail(new ParseResult.Type(ast, str, 'Expected HH:mm:ss format'));\n    }\n\n    const [year, month, day] = date.split('-').map(Number);\n    const [hours, minutes, seconds] = time.split(':').map(Number);\n    return ParseResult.succeed({ year, month, day, hours, minutes, seconds });\n  },\n  encode: (datetime) => {\n    return ParseResult.succeed(\n      [\n        [\n          datetime.year.toString().padStart(4, '0'),\n          datetime.month.toString().padStart(2, '0'),\n          datetime.day.toString().padStart(2, '0'),\n        ].join('-'),\n        [\n          datetime.hours.toString().padStart(2, '0'),\n          datetime.minutes.toString().padStart(2, '0'),\n          datetime.seconds.toString().padStart(2, '0'),\n        ].join(':'),\n      ].join('T'),\n    );\n  },\n}) */ Schema.String.pipe(\n  FormatAnnotation.set(TypeFormat.DateTime),\n  Schema.annotations({\n    title: 'DateTime',\n    description: 'Valid date and time in ISO format',\n  }),\n);\n\n/**\n * https://datatracker.ietf.org/doc/html/rfc3339#appendix-A\n */\n// TODO(burdon): Define duration type.\nexport const Duration = Schema.String.pipe(\n  FormatAnnotation.set(TypeFormat.Duration),\n  Schema.annotations({\n    title: 'Duration',\n    description: 'Duration in ISO 8601 format',\n    [SchemaAST.ExamplesAnnotationId]: ['1h', '3D'],\n  }),\n);\n\n//\n// Utils\n//\n\n// YYYY-MM-DD\nconst DATE_REGEX = /^\\d{4}-\\d{2}-\\d{2}$/;\n\nconst _isValidDateFormat = (str: string) => DATE_REGEX.test(str);\n\nconst _isValidDate = (str: string) => {\n  const date = new Date(str);\n  return !isNaN(date.getTime()) && date.toISOString().startsWith(str);\n};\n\n// HH:mm:ss\nconst TIME_REGEX = /^([01]\\d|2[0-3]):([0-5]\\d):([0-5]\\d)$/;\n\nconst _isValidTimeFormat = (str: string) => TIME_REGEX.test(str);\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\n/**\n * Schema for a single select option. Used to define choices in a {single|multi}-select field.\n */\nexport const SelectOption = Schema.Struct({\n  /** Stable identifier for the option. */\n  id: Schema.NonEmptyString,\n  title: Schema.String,\n  /** Color palette used for visual styling. */\n  color: Schema.String,\n}).pipe(Schema.mutable);\n\nexport type SelectOption = Schema.Schema.Type<typeof SelectOption>;\n"],
+  "mappings": "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",
+  "names": ["Function", "Option", "SchemaAST", "TypeEnum", "getTypeEnum", "property", "type", "undefined", "FormatAnnotationId", "Symbol", "for", "FormatAnnotation", "createAnnotationHelper", "getFormatAnnotation", "node", "pipe", "getAnnotation", "getOrUndefined", "TypeFormat", "FormatEnums", "Object", "values", "sort", "PropertyKind", "format", "typeToFormat", "formatToType", "OptionsAnnotationId", "OptionsAnnotation", "getOptionsAnnotation", "Schema", "encodeMultipleOf", "divisor", "Math", "pow", "encodeMultiple", "self", "undefined", "pipe", "multipleOf", "DecimalPrecision", "transform", "Number", "strict", "encode", "value", "decode", "log10", "annotations", "title", "CurrencyAnnotationId", "Symbol", "for", "Currency", "decimals", "code", "FormatAnnotation", "set", "TypeFormat", "description", "toUpperCase", "Integer", "int", "Percent", "Timestamp", "Schema", "clamp", "GeoPoint", "Tuple", "Number", "pipe", "annotations", "title", "clamp", "multipleOf", "optionalElement", "FormatAnnotation", "set", "TypeFormat", "description", "GeoLocation", "toGeoPoint", "longitude", "latitude", "height", "clampedLongitude", "clampedLatitude", "undefined", "fromGeoPoint", "geoPoint", "result", "Schema", "SchemaAST", "Email", "String", "pipe", "pattern", "FormatAnnotation", "set", "TypeFormat", "annotations", "title", "description", "Formula", "Hostname", "JSON", "Markdown", "Regex", "Text", "URL", "UUID", "ExamplesAnnotationId", "Schema", "Keys", "Schema", "SchemaAST", "SimpleDate", "Struct", "year", "Number", "pipe", "between", "month", "day", "SimpleTime", "Struct", "hours", "Number", "pipe", "between", "minutes", "seconds", "SimpleDateTime", "extend", "SimpleDate", "SimpleTime", "DateOnly", "String", "pipe", "FormatAnnotation", "set", "TypeFormat", "Date", "annotations", "title", "description", "TimeOnly", "Time", "DateTime", "Duration", "ExamplesAnnotationId", "Format", "TypeFormat", "DXN", "Schema", "Email", "Formula", "Hostname", "JSON", "Markdown", "Regex", "URL", "UUID", "Currency", "Integer", "Percent", "Timestamp", "Date", "DateOnly", "DateTime", "Duration", "Time", "TimeOnly", "GeoPoint", "Schema", "SelectOption", "Struct", "id", "NonEmptyString", "title", "String", "color", "pipe", "mutable"]
+}

package/dist/lib/node-esm/chunk-XHJRMQZD.mjs

@@ -0,0 +1,69 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+
+// src/internal/types/entity.ts
+import * as Schema from "effect/Schema";
+var KindId = "~@dxos/echo/Kind";
+var SchemaKindId = "~@dxos/echo/SchemaKind";
+var SnapshotKindId = "~@dxos/echo/SnapshotKind";
+var EntityKind = /* @__PURE__ */ (function(EntityKind2) {
+  EntityKind2["Object"] = "object";
+  EntityKind2["Relation"] = "relation";
+  return EntityKind2;
+})({});
+var EntityKindSchema = Schema.Enums(EntityKind);
+var ANY_OBJECT_TYPENAME = "dxos.org/schema/AnyObject";
+var ANY_OBJECT_VERSION = "0.0.0";
+
+// src/internal/annotations/util.ts
+import * as SchemaAST from "effect/SchemaAST";
+import { assertArgument } from "@dxos/invariant";
+import { DXN } from "@dxos/keys";
+var createAnnotationHelper = (id) => {
+  return {
+    get: (schema) => SchemaAST.getAnnotation(schema.ast, id),
+    getFromAst: (ast) => SchemaAST.getAnnotation(ast, id),
+    set: (value) => (schema) => schema.annotations({
+      [id]: value
+    })
+  };
+};
+var unwrapOptional = (property) => {
+  if (!property.isOptional || !SchemaAST.isUnion(property.type)) {
+    return property;
+  }
+  return property.type.types[0];
+};
+var makeTypeJsonSchemaAnnotation = (options) => {
+  assertArgument(!!options.relationSource === (options.kind === EntityKind.Relation), "relationSource");
+  assertArgument(!!options.relationTarget === (options.kind === EntityKind.Relation), "relationTarget");
+  const obj = {
+    // TODO(dmaretskyi): Should this include the version?
+    $id: options.identifier ?? DXN.fromTypename(options.typename).toString(),
+    entityKind: options.kind,
+    version: options.version,
+    typename: options.typename
+  };
+  if (options.kind === EntityKind.Relation) {
+    obj.relationSource = {
+      $ref: options.relationSource
+    };
+    obj.relationTarget = {
+      $ref: options.relationTarget
+    };
+  }
+  return obj;
+};
+
+export {
+  KindId,
+  SchemaKindId,
+  SnapshotKindId,
+  EntityKind,
+  EntityKindSchema,
+  ANY_OBJECT_TYPENAME,
+  ANY_OBJECT_VERSION,
+  createAnnotationHelper,
+  unwrapOptional,
+  makeTypeJsonSchemaAnnotation
+};
+//# sourceMappingURL=chunk-XHJRMQZD.mjs.map

package/dist/lib/node-esm/chunk-XHJRMQZD.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/types/entity.ts", "../../../src/internal/annotations/util.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\n// NOTE: String literals are used instead of unique symbols for both KindId and SchemaKindId.\n//   Unique symbols cause TS4023 \"cannot be named\" errors when external packages\n//   try to export types that reference this key (e.g., `export const Graph = ...`).\n//   TypeScript cannot emit declaration files that reference unique symbols from\n//   external modules. Using a string literal allows the type to be inlined in\n//   declaration files, making the API portable across package boundaries.\n\n/**\n * String key used to identify the kind of an entity instance (object or relation).\n */\nexport const KindId = '~@dxos/echo/Kind' as const;\nexport type KindId = typeof KindId;\n\n/**\n * String key used to identify the kind of a schema (object schema or relation schema).\n * Parallels KindId which identifies instance kinds.\n */\nexport const SchemaKindId = '~@dxos/echo/SchemaKind' as const;\nexport type SchemaKindId = typeof SchemaKindId;\n\n/**\n * String key used to brand snapshot types.\n * Snapshots have SnapshotKindId instead of KindId, making them\n * distinguishable from reactive objects at the type level.\n */\nexport const SnapshotKindId = '~@dxos/echo/SnapshotKind' as const;\nexport type SnapshotKindId = typeof SnapshotKindId;\n\n/**\n * Kinds of entities stored in ECHO: objects and relations.\n */\nexport enum EntityKind {\n  Object = 'object',\n  Relation = 'relation',\n}\n\nexport const EntityKindSchema = Schema.Enums(EntityKind);\n\n/**\n * Typename for generic object references (Type.Obj / Type.Ref(Type.Obj)).\n * Used when referencing any object without a specific schema.\n */\nexport const ANY_OBJECT_TYPENAME = 'dxos.org/schema/AnyObject';\n\n/**\n * Version for generic object references.\n */\nexport const ANY_OBJECT_VERSION = '0.0.0';\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport type * as Option from 'effect/Option';\nimport type * as Schema from 'effect/Schema';\nimport * as SchemaAST from 'effect/SchemaAST';\n\nimport { assertArgument } from '@dxos/invariant';\nimport { DXN } from '@dxos/keys';\n\nimport { EntityKind } from '../types';\n\nexport interface AnnotationHelper<T> {\n  get: (schema: Schema.Schema.Any) => Option.Option<T>;\n  getFromAst: (ast: SchemaAST.AST) => Option.Option<T>;\n  set: (value: T) => <S extends Schema.Schema.Any>(schema: S) => S;\n}\n\nexport const createAnnotationHelper = <T>(id: symbol): AnnotationHelper<T> => {\n  return {\n    get: (schema) => SchemaAST.getAnnotation(schema.ast, id),\n    getFromAst: (ast) => SchemaAST.getAnnotation(ast, id),\n    set:\n      (value) =>\n      <S extends Schema.Schema.Any>(schema: S) =>\n        schema.annotations({ [id]: value }) as S,\n  };\n};\n\n/**\n * If property is optional returns the nested property, otherwise returns the property.\n */\n// TODO(wittjosiah): Is there a way to do this as a generic?\nexport const unwrapOptional = (property: SchemaAST.PropertySignature) => {\n  if (!property.isOptional || !SchemaAST.isUnion(property.type)) {\n    return property;\n  }\n\n  return property.type.types[0];\n};\n\n/**\n * @see JSONSchemaAnnotationId\n * @returns JSON-schema annotation so that the schema can be serialized with correct parameters.\n */\n// TODO(burdon): Required type.\nexport const makeTypeJsonSchemaAnnotation = (options: {\n  identifier?: string;\n  kind: EntityKind;\n  typename: string;\n  version: string;\n  relationSource?: string;\n  relationTarget?: string;\n}) => {\n  assertArgument(!!options.relationSource === (options.kind === EntityKind.Relation), 'relationSource');\n  assertArgument(!!options.relationTarget === (options.kind === EntityKind.Relation), 'relationTarget');\n\n  const obj = {\n    // TODO(dmaretskyi): Should this include the version?\n    $id: options.identifier ?? DXN.fromTypename(options.typename).toString(),\n    entityKind: options.kind,\n    version: options.version,\n    typename: options.typename,\n  } as any;\n  if (options.kind === EntityKind.Relation) {\n    obj.relationSource = { $ref: options.relationSource };\n    obj.relationTarget = { $ref: options.relationTarget };\n  }\n\n  return obj;\n};\n"],
+  "mappings": ";;;AAIA,YAAYA,YAAY;AAYjB,IAAMC,SAAS;AAOf,IAAMC,eAAe;AAQrB,IAAMC,iBAAiB;AAMvB,IAAKC,aAAAA,0BAAAA,aAAAA;;;SAAAA;;AAKL,IAAMC,mBAA0BC,aAAMF,UAAAA;AAMtC,IAAMG,sBAAsB;AAK5B,IAAMC,qBAAqB;;;AC/ClC,YAAYC,eAAe;AAE3B,SAASC,sBAAsB;AAC/B,SAASC,WAAW;AAUb,IAAMC,yBAAyB,CAAIC,OAAAA;AACxC,SAAO;IACLC,KAAK,CAACC,WAAqBC,wBAAcD,OAAOE,KAAKJ,EAAAA;IACrDK,YAAY,CAACD,QAAkBD,wBAAcC,KAAKJ,EAAAA;IAClDM,KACE,CAACC,UACD,CAA8BL,WAC5BA,OAAOM,YAAY;MAAE,CAACR,EAAAA,GAAKO;IAAM,CAAA;EACvC;AACF;AAMO,IAAME,iBAAiB,CAACC,aAAAA;AAC7B,MAAI,CAACA,SAASC,cAAc,CAAWC,kBAAQF,SAASG,IAAI,GAAG;AAC7D,WAAOH;EACT;AAEA,SAAOA,SAASG,KAAKC,MAAM,CAAA;AAC7B;AAOO,IAAMC,+BAA+B,CAACC,YAAAA;AAQ3CC,iBAAe,CAAC,CAACD,QAAQE,oBAAoBF,QAAQG,SAASC,WAAWC,WAAW,gBAAA;AACpFJ,iBAAe,CAAC,CAACD,QAAQM,oBAAoBN,QAAQG,SAASC,WAAWC,WAAW,gBAAA;AAEpF,QAAME,MAAM;;IAEVC,KAAKR,QAAQS,cAAcC,IAAIC,aAAaX,QAAQY,QAAQ,EAAEC,SAAQ;IACtEC,YAAYd,QAAQG;IACpBY,SAASf,QAAQe;IACjBH,UAAUZ,QAAQY;EACpB;AACA,MAAIZ,QAAQG,SAASC,WAAWC,UAAU;AACxCE,QAAIL,iBAAiB;MAAEc,MAAMhB,QAAQE;IAAe;AACpDK,QAAID,iBAAiB;MAAEU,MAAMhB,QAAQM;IAAe;EACtD;AAEA,SAAOC;AACT;",
+  "names": ["Schema", "KindId", "SchemaKindId", "SnapshotKindId", "EntityKind", "EntityKindSchema", "Enums", "ANY_OBJECT_TYPENAME", "ANY_OBJECT_VERSION", "SchemaAST", "assertArgument", "DXN", "createAnnotationHelper", "id", "get", "schema", "getAnnotation", "ast", "getFromAst", "set", "value", "annotations", "unwrapOptional", "property", "isOptional", "isUnion", "type", "types", "makeTypeJsonSchemaAnnotation", "options", "assertArgument", "relationSource", "kind", "EntityKind", "Relation", "relationTarget", "obj", "$id", "identifier", "DXN", "fromTypename", "typename", "toString", "entityKind", "version", "$ref"]
+}