@dxos/echo 0.8.4-main.ead640a → 0.8.4-main.effb148878

package/src/internal/Entity/relation.ts

@@ -0,0 +1,179 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
+
+import { raise } from '@dxos/debug';
+import { assertArgument, invariant } from '@dxos/invariant';
+import { DXN } from '@dxos/keys';
+
+// Type-only imports (erased at runtime — no import cycle); `internal` may depend
+// on the top-level `Obj` / `Type` API at the type level only.
+import type * as Obj from '../../Obj';
+import type * as Type from '../../Type';
+import {
+  type TypeAnnotation,
+  TypeAnnotationId,
+  getEntityKind,
+  getSchemaTypename,
+  getTypeIdentifierAnnotation,
+  makeTypeJsonSchemaAnnotation,
+} from '../Annotation';
+import {
+  ATTR_RELATION_SOURCE,
+  ATTR_RELATION_TARGET,
+  EntityKind,
+  RelationSourceDXNId,
+  RelationSourceId,
+  RelationTargetDXNId,
+  RelationTargetId,
+  type UnknownTypeSchema,
+  getStaticTypeSchema,
+} from '../common/types';
+
+export {
+  ATTR_RELATION_SOURCE,
+  ATTR_RELATION_TARGET,
+  RelationSourceDXNId,
+  RelationSourceId,
+  RelationTargetDXNId,
+  RelationTargetId,
+};
+
+import { toJsonSchema } from '../JsonSchema';
+import { type EchoTypeSchema, makeEchoTypeSchema } from './entity';
+
+/**
+ * Source and target props on relations.
+ */
+// TODO(burdon): any?
+export type RelationSourceTargetRefs<Source = any, Target = any> = {
+  /**
+   * Source ECHO live object.
+   */
+  [RelationSourceId]: Source;
+
+  /**
+   * Target ECHO live object.
+   */
+  [RelationTargetId]: Target;
+};
+
+export type RelationSource<R> = R extends RelationSourceTargetRefs<infer Source, infer _Target> ? Source : never;
+export type RelationTarget<R> = R extends RelationSourceTargetRefs<infer _Source, infer Target> ? Target : never;
+
+/**
+ * Accepted relation endpoint: an object-kind `Type.Type` entity (slot-backed)
+ * or the branded `Obj.Unknown` schema. Source/target are constrained to these
+ * — relations only connect object-kind entities.
+ */
+export type RelationEndpoint = Type.AnyObj | UnknownTypeSchema<any, EntityKind.Object>;
+
+/**
+ * Resolves a relation endpoint to the instance type it describes — the source /
+ * target instance recorded on the relation's `RelationSourceTargetRefs`.
+ */
+export type RelationEndpointInstance<S> =
+  S extends UnknownTypeSchema<infer A, any> ? A : S extends Type.AnyObj ? Type.InstanceType<S> : unknown;
+
+export type EchoRelationSchemaOptions<TSource extends RelationEndpoint, TTarget extends RelationEndpoint> = {
+  dxn: DXN.DXN;
+  source: TSource;
+  target: TTarget;
+};
+
+/**
+ * Relation schema type with kind marker. `SourceInstance` / `TargetInstance`
+ * are the resolved endpoint instance types (see {@link RelationEndpointInstance}).
+ */
+export type EchoRelationSchema<
+  Self extends Schema.Schema.Any,
+  SourceInstance extends Obj.Unknown,
+  TargetInstance extends Obj.Unknown,
+  Fields extends Schema.Struct.Fields = Schema.Struct.Fields,
+> = EchoTypeSchema<Self, RelationSourceTargetRefs<SourceInstance, TargetInstance>, EntityKind.Relation, Fields>;
+
+/**
+ * Schema for Relation entity types.
+ */
+export const EchoRelationSchema = <Source extends RelationEndpoint, Target extends RelationEndpoint>({
+  dxn,
+  source,
+  target,
+}: EchoRelationSchemaOptions<Source, Target>) => {
+  // `source` / `target` are `Type.Type` entities (slot-backed) or the branded
+  // `Obj.Unknown` schema (used directly); resolve each to its Effect Schema for
+  // the schema-side machinery (DXN ref + entity-kind checks).
+  const sourceSchema = source != null ? (getStaticTypeSchema(source) ?? source) : source;
+  const targetSchema = target != null ? (getStaticTypeSchema(target) ?? target) : target;
+  assertArgument(Schema.isSchema(sourceSchema), 'source');
+  assertArgument(Schema.isSchema(targetSchema), 'target');
+  const typename = DXN.getName(dxn);
+  const version = DXN.getVersion(dxn);
+  invariant(version, `Type.makeRelation requires a versioned DXN: ${dxn}`);
+  const sourceDXN = getDXNForRelationSchemaRef(sourceSchema);
+  const targetDXN = getDXNForRelationSchemaRef(targetSchema);
+  if (getEntityKind(sourceSchema) !== EntityKind.Object) {
+    raise(new Error('Source schema must be an echo object schema.'));
+  }
+  if (getEntityKind(targetSchema) !== EntityKind.Object) {
+    raise(new Error('Target schema must be an echo object schema.'));
+  }
+
+  return <Self extends Schema.Schema.Any, Fields extends Schema.Struct.Fields = Schema.Struct.Fields>(
+    self: Self & { fields?: Fields },
+  ): EchoRelationSchema<Self, RelationEndpointInstance<Source>, RelationEndpointInstance<Target>, Fields> => {
+    invariant(SchemaAST.isTypeLiteral(self.ast), 'Schema must be a TypeLiteral.');
+
+    // Extract fields from the schema if available (Struct schemas have .fields).
+    const fields = ((self as any).fields ?? {}) as Fields;
+
+    const schemaWithId = Schema.extend(self, Schema.Struct({ id: Schema.String }));
+    const ast = SchemaAST.annotations(schemaWithId.ast, {
+      // TODO(dmaretskyi): `extend` kills the annotations.
+      ...self.ast.annotations,
+      [TypeAnnotationId]: {
+        kind: EntityKind.Relation,
+        typename,
+        version,
+        sourceSchema: sourceDXN,
+        targetSchema: targetDXN,
+      } satisfies TypeAnnotation,
+      // TODO(dmaretskyi): TypeIdentifierAnnotationId?
+
+      [SchemaAST.JSONSchemaAnnotationId]: makeTypeJsonSchemaAnnotation({
+        kind: EntityKind.Relation,
+        typename,
+        version,
+        relationSource: sourceDXN,
+        relationTarget: targetDXN,
+      }),
+    });
+
+    return makeEchoTypeSchema<Self, EntityKind.Relation, Fields>(
+      fields,
+      ast,
+      typename,
+      version,
+      EntityKind.Relation,
+      () => toJsonSchema(Schema.make(ast)),
+    );
+  };
+};
+
+export const getDXNForRelationSchemaRef = (schema: Schema.Schema.Any): DXN.DXN => {
+  assertArgument(Schema.isSchema(schema), 'schema');
+  const identifier = getTypeIdentifierAnnotation(schema);
+  if (identifier) {
+    return DXN.tryMake(identifier) ?? raise(new Error(`Invalid schema identifier: ${identifier}`));
+  }
+
+  const typename = getSchemaTypename(schema);
+  if (!typename) {
+    throw new Error('Schema must have a typename');
+  }
+
+  return DXN.make(typename);
+};

package/src/internal/Entity/type-kind.ts

@@ -0,0 +1,67 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
+
+import { invariant } from '@dxos/invariant';
+import { DXN } from '@dxos/keys';
+
+import { type TypeAnnotation, TypeAnnotationId, makeTypeJsonSchemaAnnotation } from '../Annotation';
+import { EntityKind } from '../common/types';
+import { toJsonSchema } from '../JsonSchema';
+import { type EchoTypeSchema, makeEchoTypeSchema } from './entity';
+
+/**
+ * Type-kind schema marker — produced by {@link EchoTypeKindSchema}.
+ *
+ * Distinguishes meta-schemas (entities of `EntityKind.Type`, such as the
+ * built-in `Type.Type` TypeSchema) from object and relation types.
+ */
+export type EchoTypeKindSchema<
+  Self extends Schema.Schema.Any,
+  Fields extends Schema.Struct.Fields = Schema.Struct.Fields,
+> = EchoTypeSchema<Self, {}, EntityKind.Type, Fields>;
+
+/**
+ * Pipeable that brands a schema as a type-kind ECHO entity. Mirrors
+ * {@link EchoObjectSchema} / {@link EchoRelationSchema}, but stamps the
+ * resulting entity with `[SchemaKindId]: EntityKind.Type` and a matching
+ * `TypeAnnotation.kind = 'type'` so meta-schemas surface uniformly through
+ * `Type.isTypeKindSchema`, `Filter.type`, etc.
+ */
+export const EchoTypeKindSchema: {
+  (
+    dxn: DXN.DXN,
+  ): <Self extends Schema.Schema.Any, Fields extends Schema.Struct.Fields = Schema.Struct.Fields>(
+    self: Self & { fields?: Fields },
+  ) => EchoTypeKindSchema<Self, Fields>;
+} = (dxn) => {
+  const typename = DXN.getName(dxn);
+  const version = DXN.getVersion(dxn);
+  invariant(version, `Type-kind schemas require a versioned DXN: ${dxn}`);
+
+  return <Self extends Schema.Schema.Any, Fields extends Schema.Struct.Fields = Schema.Struct.Fields>(
+    self: Self & { fields?: Fields },
+  ): EchoTypeKindSchema<Self, Fields> => {
+    invariant(SchemaAST.isTypeLiteral(self.ast), 'Schema must be a TypeLiteral.');
+
+    const fields = ((self as any).fields ?? {}) as Fields;
+
+    const schemaWithId = Schema.extend(self, Schema.Struct({ id: Schema.String }));
+    const ast = SchemaAST.annotations(schemaWithId.ast, {
+      ...self.ast.annotations,
+      [TypeAnnotationId]: { kind: EntityKind.Type, typename, version } satisfies TypeAnnotation,
+      [SchemaAST.JSONSchemaAnnotationId]: makeTypeJsonSchemaAnnotation({
+        kind: EntityKind.Type,
+        typename,
+        version,
+      }),
+    });
+
+    return makeEchoTypeSchema<Self, EntityKind.Type, Fields>(fields, ast, typename, version, EntityKind.Type, () =>
+      toJsonSchema(Schema.make(ast)),
+    );
+  };
+};

package/src/internal/Entity/type-uri.ts

@@ -0,0 +1,87 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { raise } from '@dxos/debug';
+import { assertArgument } from '@dxos/invariant';
+import { DXN, URI } from '@dxos/keys';
+
+import { getSchemaURI, getTypename } from '../Annotation';
+import { type AnyEntity, InstancePhantomId, KindId, TypeId, getStaticTypeSchema } from '../common/types';
+import { getUri as getUriFromEntity } from './api';
+
+/**
+ * @param input schema, `Type.Type` entity, or a typename string.
+ * @return type identifier URI — see {@link getSchemaURI}. For a typename string,
+ * always a DXN. For a `Type.Type` entity, the URI of the schema it declares,
+ * symmetric with what `Obj.make(typeEntity, ...)` stamps on `system.type`: a
+ * static declaration resolves to its typename DXN, a persisted entity to its
+ * local `echo:/<objectId>`.
+ */
+export const getTypeURIFromSpecifier = (input: Schema.Schema.All | AnyEntity | string): URI.URI => {
+  if (Schema.isSchema(input)) {
+    return getSchemaURI(input) ?? raise(new TypeError('Schema has no URI'));
+  }
+  if (typeof input === 'object' && input !== null && KindId in input) {
+    // `Type.Type` entity. Both in-memory and persisted forms expose the schema
+    // they declare via `StaticTypeSchemaSlot`, whose URI is exactly what
+    // `Obj.make` stamps on `system.type` — a static declaration carries
+    // `TypeAnnotation` (→ typename DXN), a persisted entity's rebuilt schema
+    // carries `TypeIdentifierAnnotation` (→ local `echo:/<objectId>`).
+    const schema = getStaticTypeSchema(input);
+    if (schema != null) {
+      return getSchemaURI(schema) ?? raise(new TypeError('Type entity has no URI'));
+    }
+    return getUriFromEntity(input as AnyEntity);
+  }
+  assertArgument(typeof input === 'string', 'input');
+  assertArgument(!input.startsWith('dxn:'), 'input');
+  return DXN.make(input);
+};
+
+/**
+ * Checks if the object is an instance of the schema.
+ * Only typename is compared, the schema version is ignored.
+ *
+ * The following cases are considered to mean that the object is an instance of the schema:
+ *  - Object was created with this exact schema.
+ *  - Object was created with a different version of this schema.
+ *  - Object was created with a different schema (maybe dynamic) that has the same typename.
+ */
+// TODO(burdon): Can we use `Schema.is`?
+export const isInstanceOf = <S>(
+  schemaOrType: S extends Schema.Schema.AnyNoContext ? S : Schema.Schema.AnyNoContext | AnyEntity,
+  object: any,
+): object is S extends Schema.Schema.AnyNoContext
+  ? Schema.Schema.Type<S>
+  : S extends { readonly [InstancePhantomId]?: infer A }
+    ? A
+    : unknown => {
+  if (object == null) {
+    return false;
+  }
+
+  const schemaURI = getTypeURIFromSpecifier(schemaOrType);
+
+  // `object` is arbitrary input — read TypeId directly (it may be missing on
+  // non-entities) rather than via `getTypeURI` which asserts the URI is set.
+  const type = (object as any)[TypeId];
+  if (URI.isURI(type) && type === schemaURI) {
+    return true;
+  }
+
+  const typename = getTypename(object);
+  if (!typename) {
+    return false;
+  }
+
+  if (!DXN.isDXN(schemaURI)) {
+    // EchoURI-based schema URI — no typename match possible.
+    return false;
+  }
+
+  const parsed = DXN.tryMake(schemaURI);
+  return parsed != null && DXN.getName(parsed) === typename;
+};

package/src/internal/Entity/util.ts

@@ -0,0 +1,34 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { assertArgument, invariant } from '@dxos/invariant';
+import { EchoURI, ObjectId } from '@dxos/keys';
+import { assumeType } from '@dxos/util';
+
+import { type InternalObjectProps, SelfURIId } from './model';
+
+/**
+ * Returns the EchoURI of an object.
+ * Normalizes any legacy `dxn:echo:` / `dxn:queue:` form stored in `SelfURIId`.
+ *
+ * @internal
+ */
+export const getObjectEchoUri = (object: any): EchoURI.EchoURI | undefined => {
+  invariant(!Schema.isSchema(object), 'schema not allowed in this function');
+  assertArgument(typeof object === 'object' && object != null, 'object', 'expected object');
+  assumeType<InternalObjectProps>(object);
+
+  if (object[SelfURIId]) {
+    invariant(EchoURI.isEchoURI(object[SelfURIId]), 'Invalid object model: invalid self dxn');
+    return EchoURI.parse(object[SelfURIId]);
+  }
+
+  if (!ObjectId.isValid(object.id)) {
+    throw new TypeError('Object id is not valid.');
+  }
+
+  return EchoURI.make({ objectId: object.id });
+};

package/src/internal/Entity/version.ts

@@ -0,0 +1,96 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { assertArgument } from '@dxos/invariant';
+
+import { type AnyEntity, VersionTypeId } from '../common/types';
+import { ObjectVersionId } from './model';
+
+/**
+ * Represent entity version.
+ * May be backed by Automerge.
+ * Entities with no history are not versioned.
+ * Named EntityVersion to avoid conflict with types/version.ts.
+ */
+export interface EntityVersion {
+  [VersionTypeId]: {};
+
+  /**
+   * Whether the entity is versioned.
+   */
+  versioned: boolean;
+
+  /**
+   * Automerge heads.
+   */
+  automergeHeads?: string[];
+}
+
+const unversioned: EntityVersion = {
+  [VersionTypeId]: {},
+  versioned: false,
+};
+
+/**
+ * Checks that `obj` is a version object.
+ */
+export const isVersion = (entity: unknown): entity is EntityVersion => {
+  return entity != null && typeof entity === 'object' && VersionTypeId in entity;
+};
+
+/**
+ * Returns the version of an entity.
+ * Accepts both reactive entities and snapshots.
+ */
+export const version = (entity: AnyEntity): EntityVersion => {
+  const ver = (entity as any)[ObjectVersionId];
+  if (ver === undefined) {
+    return unversioned;
+  }
+  return ver;
+};
+
+/**
+ * Checks that `version` is a valid version object.
+ */
+export const versionValid = (ver: EntityVersion): boolean => {
+  assertArgument(isVersion(ver), 'version', 'Invalid version object');
+  return !!ver.versioned;
+};
+
+export type VersionCompareResult = 'unversioned' | 'equal' | 'different';
+
+/**
+ * Compares two versions.
+ * @param version1
+ * @param version2
+ * @returns 'unversioned' if either entity is unversioned, 'equal' if the versions are equal, 'different' if the versions are different.
+ */
+export const compareVersions = (version1: EntityVersion, version2: EntityVersion): VersionCompareResult => {
+  assertArgument(isVersion(version1), 'version1', 'Invalid version object');
+  assertArgument(isVersion(version2), 'version2', 'Invalid version object');
+
+  if (!versionValid(version1) || !versionValid(version2)) {
+    return 'unversioned';
+  }
+
+  if (version1.automergeHeads?.length !== version2.automergeHeads?.length) {
+    return 'different';
+  }
+  if (version1.automergeHeads?.some((head) => !version2.automergeHeads?.includes(head))) {
+    return 'different';
+  }
+
+  return 'equal';
+};
+
+export const encodeVersion = (ver: EntityVersion): string => {
+  return JSON.stringify(ver);
+};
+
+export const decodeVersion = (ver: string): EntityVersion => {
+  const parsed = JSON.parse(ver);
+  parsed[VersionTypeId] = {};
+  return parsed;
+};

package/src/internal/{formats → Format}/date.test.ts

@@ -7,8 +7,7 @@ import { describe, expect, test } from 'vitest';
 
 import { log } from '@dxos/log';
 
-import { toJsonSchema } from '../json';
-
+import { toJsonSchema } from '../JsonSchema';
 import {
   DateOnly,
   DateTime,

package/src/internal/{formats → Format}/date.ts

@@ -5,7 +5,7 @@
 import * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
 
-import { FormatAnnotation, FormatEnum } from './types';
+import { FormatAnnotation, TypeFormat } from './types';
 
 /**
  * Datetime values should be stored as ISO strings or unix numbers (ms) in UTC.
@@ -102,9 +102,8 @@ export const DateOnly = /* Schema.transformOrFail(Schema.String, SimpleDate, {
     );
   },
 }) */ Schema.String.pipe(
-  FormatAnnotation.set(FormatEnum.Date),
+  FormatAnnotation.set(TypeFormat.Date),
   Schema.annotations({
-    title: 'Date',
     description: 'Valid date in ISO format',
   }),
 );
@@ -132,9 +131,8 @@ export const TimeOnly = /* Schema.transformOrFail(Schema.String, SimpleTime, {
     );
   },
 }) */ Schema.String.pipe(
-  FormatAnnotation.set(FormatEnum.Time),
+  FormatAnnotation.set(TypeFormat.Time),
   Schema.annotations({
-    title: 'Time',
     description: 'Valid time in ISO format',
   }),
 );
@@ -177,9 +175,8 @@ export const DateTime = /* Schema.transformOrFail(Schema.String, SimpleDateTime,
     );
   },
 }) */ Schema.String.pipe(
-  FormatAnnotation.set(FormatEnum.DateTime),
+  FormatAnnotation.set(TypeFormat.DateTime),
   Schema.annotations({
-    title: 'DateTime',
     description: 'Valid date and time in ISO format',
   }),
 );
@@ -189,9 +186,8 @@ export const DateTime = /* Schema.transformOrFail(Schema.String, SimpleDateTime,
  */
 // TODO(burdon): Define duration type.
 export const Duration = Schema.String.pipe(
-  FormatAnnotation.set(FormatEnum.Duration),
+  FormatAnnotation.set(TypeFormat.Duration),
   Schema.annotations({
-    title: 'Duration',
     description: 'Duration in ISO 8601 format',
     [SchemaAST.ExamplesAnnotationId]: ['1h', '3D'],
   }),

package/src/internal/{formats → Format}/format.test.ts

@@ -5,10 +5,9 @@
 import * as Schema from 'effect/Schema';
 import { describe, test } from 'vitest';
 
-import { toJsonSchema } from '../json';
-
+import { toJsonSchema } from '../JsonSchema';
 import { Format } from './format';
-import { FormatEnum, TypeEnum, getTypeEnum } from './types';
+import { TypeEnum, TypeFormat, getTypeEnum } from './types';
 
 describe('formats', () => {
   test('annotations', ({ expect }) => {
@@ -20,7 +19,7 @@ describe('formats', () => {
       birthday: Schema.optional(Format.Date),
       started: Schema.optional(Format.DateTime),
       active: Schema.optional(Schema.Boolean),
-    }).pipe(Schema.mutable);
+    });
 
     type TestType = Schema.Schema.Type<typeof TestSchema>;
 
@@ -48,7 +47,7 @@ describe('formats', () => {
       expect(getTypeEnum(prop)).to.eq(TypeEnum.String);
       expect(prop).includes({
         type: TypeEnum.String,
-        format: FormatEnum.Email,
+        format: TypeFormat.Email,
         title: 'Email',
       });
     }
@@ -58,7 +57,7 @@ describe('formats', () => {
       expect(getTypeEnum(prop)).to.eq(TypeEnum.Number);
       expect(prop).includes({
         type: TypeEnum.Number,
-        format: FormatEnum.Currency,
+        format: TypeFormat.Currency,
         title: 'Currency',
         multipleOf: 0.01,
         currency: 'USD',
@@ -70,7 +69,7 @@ describe('formats', () => {
       expect(getTypeEnum(prop)).to.eq(TypeEnum.String);
       expect(prop).includes({
         type: TypeEnum.String,
-        format: FormatEnum.Date,
+        format: TypeFormat.Date,
       });
     }
   });

package/src/internal/{formats → Format}/format.ts

@@ -10,10 +10,10 @@ import * as DateUtil from './date';
 import * as NumberUtil from './number';
 import * as ObjectUtil from './object';
 import * as StringUtil from './string';
+import { TypeFormat as TypeFormat$ } from './types';
 
-// TODO(burdon): Consider factoring out to separate `@dxos/json-schema`
 // TODO(burdon): Media encoding.
-//  - https://json-schema.org/understanding-json-schema/reference/non_json_data
+// - https://json-schema.org/understanding-json-schema/reference/non_json_data
 
 /**
  * Formats.
@@ -22,7 +22,9 @@ import * as StringUtil from './string';
  */
 // TODO(burdon): Add fields for `examples`, `message`, etc.
 export namespace Format {
-  // Strings
+  export import TypeFormat = TypeFormat$;
+
+  // String
   export const DXN = Keys.DXN.Schema;
   export const Email = StringUtil.Email;
   export const Formula = StringUtil.Formula;
@@ -41,12 +43,12 @@ export namespace Format {
   export const Timestamp = NumberUtil.Timestamp;
 
   // Dates and times
-  export const DateTime = DateUtil.DateTime;
   export const Date = DateUtil.DateOnly;
-  export const Time = DateUtil.TimeOnly;
+  export const DateTime = DateUtil.DateTime;
   export const Duration = DateUtil.Duration;
+  export const Time = DateUtil.TimeOnly;
 
   // Objects
   export const GeoPoint = ObjectUtil.GeoPoint;
-  export type GeoPoint = ObjectUtil.GeoPoint;
+  export type GeoPoint = ObjectUtil.GeoPoint; // TODO(burdon): Export types.
 }

package/src/internal/{formats → Format}/index.ts

@@ -2,11 +2,10 @@
 // Copyright 2025 DXOS.org
 //
 
-export type { SimpleDate, SimpleDateTime, SimpleTime } from './date';
+export * from './date';
+export * from './format';
 export { CurrencyAnnotationId, DecimalPrecision, Currency } from './number';
 export { GeoPoint, GeoLocation } from './object';
-
-export * from './format';
 export * from './select';
 export * from './string';
 export * from './types';

package/src/internal/{formats → Format}/number.ts

@@ -4,7 +4,7 @@
 
 import * as Schema from 'effect/Schema';
 
-import { FormatAnnotation, FormatEnum } from './types';
+import { FormatAnnotation, TypeFormat } from './types';
 
 const encodeMultipleOf = (divisor: number) => 1 / Math.pow(10, divisor);
 
@@ -37,7 +37,7 @@ export type CurrencyAnnotation = {
 export const Currency = ({ decimals, code }: CurrencyAnnotation = { decimals: 2 }) =>
   Schema.Number.pipe(
     encodeMultiple(decimals),
-    FormatAnnotation.set(FormatEnum.Currency),
+    FormatAnnotation.set(TypeFormat.Currency),
     Schema.annotations({
       title: 'Currency',
       description: 'Currency value',
@@ -55,7 +55,7 @@ export type PercentAnnotation = {
 export const Integer = () =>
   Schema.Number.pipe(
     Schema.int(),
-    FormatAnnotation.set(FormatEnum.Integer),
+    FormatAnnotation.set(TypeFormat.Integer),
     Schema.annotations({
       title: 'Integer',
       description: 'Integer value',
@@ -69,7 +69,7 @@ export const Integer = () =>
 export const Percent = ({ decimals }: PercentAnnotation = { decimals: 2 }) =>
   Schema.Number.pipe(
     encodeMultiple(decimals),
-    FormatAnnotation.set(FormatEnum.Percent),
+    FormatAnnotation.set(TypeFormat.Percent),
     Schema.annotations({
       title: 'Percent',
       description: 'Percentage value',
@@ -81,7 +81,7 @@ export const Percent = ({ decimals }: PercentAnnotation = { decimals: 2 }) =>
  * https://en.wikipedia.org/wiki/Unix_time
  */
 export const Timestamp = Schema.Number.pipe(
-  FormatAnnotation.set(FormatEnum.Timestamp),
+  FormatAnnotation.set(TypeFormat.Timestamp),
   Schema.annotations({
     title: 'Timestamp',
     description: 'Unix timestamp',