@dxos/echo 0.8.4-main.937b3ca → 0.8.4-main.9735255

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

@@ -1,403 +0,0 @@
-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-XHJRMQZD.mjs

@@ -1,69 +0,0 @@
-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-Y75VU7LB.mjs

@@ -1,74 +0,0 @@
-import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-import {
-  Currency,
-  CurrencyAnnotationId,
-  DecimalPrecision,
-  Email,
-  Format,
-  FormatAnnotation,
-  FormatAnnotationId,
-  FormatEnums,
-  Formula,
-  GeoLocation,
-  GeoPoint,
-  Hostname,
-  JSON,
-  Markdown,
-  OptionsAnnotation,
-  OptionsAnnotationId,
-  PropertyKind,
-  Regex,
-  SelectOption,
-  Text,
-  TypeEnum,
-  TypeFormat,
-  URL,
-  UUID,
-  formatToType,
-  getFormatAnnotation,
-  getOptionsAnnotation,
-  getTypeEnum,
-  typeToFormat
-} from "./chunk-W6QIEBTQ.mjs";
-import {
-  __export
-} from "./chunk-HSLMI22Q.mjs";
-
-// src/Format.ts
-var Format_exports = {};
-__export(Format_exports, {
-  Currency: () => Currency,
-  CurrencyAnnotationId: () => CurrencyAnnotationId,
-  DecimalPrecision: () => DecimalPrecision,
-  Email: () => Email,
-  Format: () => Format,
-  FormatAnnotation: () => FormatAnnotation,
-  FormatAnnotationId: () => FormatAnnotationId,
-  FormatEnums: () => FormatEnums,
-  Formula: () => Formula,
-  GeoLocation: () => GeoLocation,
-  GeoPoint: () => GeoPoint,
-  Hostname: () => Hostname,
-  JSON: () => JSON,
-  Markdown: () => Markdown,
-  OptionsAnnotation: () => OptionsAnnotation,
-  OptionsAnnotationId: () => OptionsAnnotationId,
-  PropertyKind: () => PropertyKind,
-  Regex: () => Regex,
-  SelectOption: () => SelectOption,
-  Text: () => Text,
-  TypeEnum: () => TypeEnum,
-  TypeFormat: () => TypeFormat,
-  URL: () => URL,
-  UUID: () => UUID,
-  formatToType: () => formatToType,
-  getFormatAnnotation: () => getFormatAnnotation,
-  getOptionsAnnotation: () => getOptionsAnnotation,
-  getTypeEnum: () => getTypeEnum,
-  typeToFormat: () => typeToFormat
-});
-
-export {
-  Format_exports
-};
-//# sourceMappingURL=chunk-Y75VU7LB.mjs.map