@atproto/lex-schema 0.0.19 → 0.1.0-next.0

package/dist/schema/blob.js.map

@@ -1 +1 @@
-{"version":3,"file":"blob.js","sourceRoot":"","sources":["../../src/schema/blob.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  BlobRef,\n  LegacyBlobRef,\n  TypedBlobRef,\n  getBlobSize,\n  isBlobRef,\n  isLegacyBlobRef,\n  isTypedBlobRef,\n} from '@atproto/lex-data'\nimport { Schema, ValidationContext } from '../core.js'\nimport { memoizedOptions } from '../util/memoize.js'\n\n/**\n * Configuration options for blob schema validation.\n */\nexport type BlobSchemaOptions = {\n  /**\n   * List of accepted MIME types (supports wildcards like 'image/*' or '*\\/*')\n   *\n   * @default undefined // accepts all MIME types\n   */\n  accept?: string[]\n\n  /**\n   * Maximum blob size in bytes\n   *\n   * @default undefined // no size limit\n   */\n  maxSize?: number\n}\n\nexport type { BlobRef, LegacyBlobRef, TypedBlobRef }\nexport { isBlobRef, isLegacyBlobRef, isTypedBlobRef }\n\n/**\n * Schema for validating blob references in AT Protocol.\n *\n * Validates BlobRef objects which contain a CID reference to binary data,\n * along with metadata like MIME type and size. Can optionally accept\n * legacy blob reference format.\n *\n * @template TOptions - The configuration options type\n *\n * @example\n * ```ts\n * const schema = new BlobSchema({ accept: ['image/*'], maxSize: 1000000 })\n * const result = schema.validate(blobRef)\n * ```\n */\nexport class BlobSchema<\n  const TOptions extends BlobSchemaOptions = NonNullable<unknown>,\n> extends Schema<BlobRef> {\n  readonly type = 'blob' as const\n\n  constructor(readonly options?: TOptions) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    const blob = parseValue.call(ctx, input)\n    if (!blob) {\n      return ctx.issueUnexpectedType(input, 'blob')\n    }\n\n    // In non-strict mode, we allow blob refs to pass through without MIME\n    // type or size checks.\n    if (ctx.options.strict && this.options != null) {\n      const { accept } = this.options\n      if (accept && !matchesMime(blob.mimeType, accept)) {\n        return ctx.issueInvalidPropertyValue(blob, 'mimeType', accept)\n      }\n\n      const { maxSize } = this.options\n      if (maxSize != null) {\n        const size = getBlobSize(blob)\n        if (size === undefined) {\n          // Unable to enforce size constraint if size is not available (legacy\n          // blob ref), so we treat it as a validation failure in strict mode.\n          return ctx.issueInvalidPropertyType(blob, 'size' as any, 'integer')\n        } else if (size > maxSize) {\n          return ctx.issueTooBig(blob, 'blob', maxSize, size)\n        }\n      }\n    }\n\n    return ctx.success(blob)\n  }\n\n  matchesMime(mime: string): boolean {\n    const accept = this.options?.accept\n    if (!accept) return true\n    return matchesMime(mime, accept)\n  }\n}\n\nfunction parseValue(this: ValidationContext, input: unknown): BlobRef | null {\n  // If there is a $type property, we treat if as a potential TypedBlobRef and\n  // validate accordingly.\n  if ((input as any)?.$type !== undefined) {\n    // Use the context's option for the \"strict\" check\n    return isTypedBlobRef(input, this.options) ? input : null\n  }\n\n  // If there is no $type property, we may be dealing with a legacy blob ref. If\n  // legacy refs are allowed (non-strict mode), we check if the input matches\n  // the legacy format.\n  if (!this.options.strict) {\n    if (isLegacyBlobRef(input, this.options)) return input\n  }\n\n  return null\n}\n\nfunction matchesMime(mime: string, accepted: string[]): boolean {\n  if (accepted.includes('*/*')) return true\n  if (accepted.includes(mime)) return true\n  for (const value of accepted) {\n    if (value.endsWith('/*') && mime.startsWith(value.slice(0, -1))) {\n      return true\n    }\n  }\n  return false\n}\n\n/**\n * Creates a blob schema for validating blob references with optional constraints.\n *\n * Blob references are used in AT Protocol to reference binary data stored\n * separately from records. They contain a CID, MIME type, and size information.\n *\n * @param options - Optional configuration for MIME type filtering and size limits\n * @returns A new {@link BlobSchema} instance\n *\n * @example\n * ```ts\n * // Basic blob reference\n * const fileSchema = l.blob()\n *\n * // Image files only\n * const imageSchema = l.blob({ accept: ['image/png', 'image/jpeg', 'image/gif'] })\n *\n * // Any image type with size limit\n * const avatarSchema = l.blob({ accept: ['image/*'], maxSize: 1000000 })\n * ```\n */\nexport const blob = /*#__PURE__*/ memoizedOptions(function <\n  O extends BlobSchemaOptions = NonNullable<unknown>,\n>(options?: O) {\n  return new BlobSchema(options)\n})\n"]}
+{"version":3,"file":"blob.js","sourceRoot":"","sources":["../../src/schema/blob.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,WAAW,EACX,SAAS,EACT,eAAe,EACf,cAAc,GACf,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EAAE,MAAM,EAAqB,MAAM,YAAY,CAAA;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAsBpD,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,cAAc,EAAE,CAAA;AAErD;;;;;;;;;;;;;;GAcG;AACH,MAAM,OAAO,UAEX,SAAQ,MAAe;IAGvB,YAAqB,OAAkB;QACrC,KAAK,EAAE,CAAA;QADY,YAAO,GAAP,OAAO,CAAW;QAF9B,SAAI,GAAG,MAAe,CAAA;IAI/B,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC,GAAG,EAAE,KAAK,CAAC,CAAA;QACxC,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,OAAO,GAAG,CAAC,mBAAmB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAA;QAC/C,CAAC;QAED,sEAAsE;QACtE,uBAAuB;QACvB,IAAI,GAAG,CAAC,OAAO,CAAC,MAAM,IAAI,IAAI,CAAC,OAAO,IAAI,IAAI,EAAE,CAAC;YAC/C,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC,OAAO,CAAA;YAC/B,IAAI,MAAM,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,EAAE,MAAM,CAAC,EAAE,CAAC;gBAClD,OAAO,GAAG,CAAC,yBAAyB,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,CAAC,CAAA;YAChE,CAAC;YAED,MAAM,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC,OAAO,CAAA;YAChC,IAAI,OAAO,IAAI,IAAI,EAAE,CAAC;gBACpB,MAAM,IAAI,GAAG,WAAW,CAAC,IAAI,CAAC,CAAA;gBAC9B,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;oBACvB,qEAAqE;oBACrE,oEAAoE;oBACpE,OAAO,GAAG,CAAC,wBAAwB,CAAC,IAAI,EAAE,MAAa,EAAE,SAAS,CAAC,CAAA;gBACrE,CAAC;qBAAM,IAAI,IAAI,GAAG,OAAO,EAAE,CAAC;oBAC1B,OAAO,GAAG,CAAC,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC,CAAA;gBACrD,CAAC;YACH,CAAC;QACH,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;IAC1B,CAAC;IAED,WAAW,CAAC,IAAY;QACtB,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,EAAE,MAAM,CAAA;QACnC,IAAI,CAAC,MAAM;YAAE,OAAO,IAAI,CAAA;QACxB,OAAO,WAAW,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;IAClC,CAAC;CACF;AAED,SAAS,UAAU,CAA0B,KAAc;IACzD,4EAA4E;IAC5E,wBAAwB;IACxB,IAAK,KAAa,EAAE,KAAK,KAAK,SAAS,EAAE,CAAC;QACxC,kDAAkD;QAClD,OAAO,cAAc,CAAC,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAA;IAC3D,CAAC;IAED,8EAA8E;IAC9E,2EAA2E;IAC3E,qBAAqB;IACrB,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;QACzB,IAAI,eAAe,CAAC,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC;YAAE,OAAO,KAAK,CAAA;IACxD,CAAC;IAED,OAAO,IAAI,CAAA;AACb,CAAC;AAED,SAAS,WAAW,CAAC,IAAY,EAAE,QAAkB;IACnD,IAAI,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC;QAAE,OAAO,IAAI,CAAA;IACzC,IAAI,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,CAAA;IACxC,KAAK,MAAM,KAAK,IAAI,QAAQ,EAAE,CAAC;QAC7B,IAAI,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YAChE,OAAO,IAAI,CAAA;QACb,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAA;AACd,CAAC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,aAAa,CAAC,eAAe,CAAC,UAEhD,OAAW;IACX,OAAO,IAAI,UAAU,CAAC,OAAO,CAAC,CAAA;AAChC,CAAC,CAAC,CAAA","sourcesContent":["import {\n  BlobRef,\n  LegacyBlobRef,\n  TypedBlobRef,\n  getBlobSize,\n  isBlobRef,\n  isLegacyBlobRef,\n  isTypedBlobRef,\n} from '@atproto/lex-data'\nimport { Schema, ValidationContext } from '../core.js'\nimport { memoizedOptions } from '../util/memoize.js'\n\n/**\n * Configuration options for blob schema validation.\n */\nexport type BlobSchemaOptions = {\n  /**\n   * List of accepted MIME types (supports wildcards like 'image/*' or '*\\/*')\n   *\n   * @default undefined // accepts all MIME types\n   */\n  accept?: string[]\n\n  /**\n   * Maximum blob size in bytes\n   *\n   * @default undefined // no size limit\n   */\n  maxSize?: number\n}\n\nexport type { BlobRef, LegacyBlobRef, TypedBlobRef }\nexport { isBlobRef, isLegacyBlobRef, isTypedBlobRef }\n\n/**\n * Schema for validating blob references in AT Protocol.\n *\n * Validates BlobRef objects which contain a CID reference to binary data,\n * along with metadata like MIME type and size. Can optionally accept\n * legacy blob reference format.\n *\n * @template TOptions - The configuration options type\n *\n * @example\n * ```ts\n * const schema = new BlobSchema({ accept: ['image/*'], maxSize: 1000000 })\n * const result = schema.validate(blobRef)\n * ```\n */\nexport class BlobSchema<\n  const TOptions extends BlobSchemaOptions = NonNullable<unknown>,\n> extends Schema<BlobRef> {\n  readonly type = 'blob' as const\n\n  constructor(readonly options?: TOptions) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    const blob = parseValue.call(ctx, input)\n    if (!blob) {\n      return ctx.issueUnexpectedType(input, 'blob')\n    }\n\n    // In non-strict mode, we allow blob refs to pass through without MIME\n    // type or size checks.\n    if (ctx.options.strict && this.options != null) {\n      const { accept } = this.options\n      if (accept && !matchesMime(blob.mimeType, accept)) {\n        return ctx.issueInvalidPropertyValue(blob, 'mimeType', accept)\n      }\n\n      const { maxSize } = this.options\n      if (maxSize != null) {\n        const size = getBlobSize(blob)\n        if (size === undefined) {\n          // Unable to enforce size constraint if size is not available (legacy\n          // blob ref), so we treat it as a validation failure in strict mode.\n          return ctx.issueInvalidPropertyType(blob, 'size' as any, 'integer')\n        } else if (size > maxSize) {\n          return ctx.issueTooBig(blob, 'blob', maxSize, size)\n        }\n      }\n    }\n\n    return ctx.success(blob)\n  }\n\n  matchesMime(mime: string): boolean {\n    const accept = this.options?.accept\n    if (!accept) return true\n    return matchesMime(mime, accept)\n  }\n}\n\nfunction parseValue(this: ValidationContext, input: unknown): BlobRef | null {\n  // If there is a $type property, we treat if as a potential TypedBlobRef and\n  // validate accordingly.\n  if ((input as any)?.$type !== undefined) {\n    // Use the context's option for the \"strict\" check\n    return isTypedBlobRef(input, this.options) ? input : null\n  }\n\n  // If there is no $type property, we may be dealing with a legacy blob ref. If\n  // legacy refs are allowed (non-strict mode), we check if the input matches\n  // the legacy format.\n  if (!this.options.strict) {\n    if (isLegacyBlobRef(input, this.options)) return input\n  }\n\n  return null\n}\n\nfunction matchesMime(mime: string, accepted: string[]): boolean {\n  if (accepted.includes('*/*')) return true\n  if (accepted.includes(mime)) return true\n  for (const value of accepted) {\n    if (value.endsWith('/*') && mime.startsWith(value.slice(0, -1))) {\n      return true\n    }\n  }\n  return false\n}\n\n/**\n * Creates a blob schema for validating blob references with optional constraints.\n *\n * Blob references are used in AT Protocol to reference binary data stored\n * separately from records. They contain a CID, MIME type, and size information.\n *\n * @param options - Optional configuration for MIME type filtering and size limits\n * @returns A new {@link BlobSchema} instance\n *\n * @example\n * ```ts\n * // Basic blob reference\n * const fileSchema = l.blob()\n *\n * // Image files only\n * const imageSchema = l.blob({ accept: ['image/png', 'image/jpeg', 'image/gif'] })\n *\n * // Any image type with size limit\n * const avatarSchema = l.blob({ accept: ['image/*'], maxSize: 1000000 })\n * ```\n */\nexport const blob = /*#__PURE__*/ memoizedOptions(function <\n  O extends BlobSchemaOptions = NonNullable<unknown>,\n>(options?: O) {\n  return new BlobSchema(options)\n})\n"]}

package/dist/schema/boolean.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.boolean = exports.BooleanSchema = void 0;
-const core_js_1 = require("../core.js");
-const memoize_js_1 = require("../util/memoize.js");
+import { Schema } from '../core.js';
+import { memoizedOptions } from '../util/memoize.js';
 /**
  * Schema for validating boolean values.
  *
@@ -17,8 +14,11 @@ const memoize_js_1 = require("../util/memoize.js");
  * schema.validate('true') // fails - no string coercion
  * ```
  */
-class BooleanSchema extends core_js_1.Schema {
-    type = 'boolean';
+export class BooleanSchema extends Schema {
+    constructor() {
+        super(...arguments);
+        this.type = 'boolean';
+    }
     validateInContext(input, ctx) {
         if (typeof input === 'boolean') {
             return ctx.success(input);
@@ -26,7 +26,6 @@ class BooleanSchema extends core_js_1.Schema {
         return ctx.issueUnexpectedType(input, 'boolean');
     }
 }
-exports.BooleanSchema = BooleanSchema;
 /**
  * Creates a boolean schema that validates true/false values.
  *
@@ -41,7 +40,7 @@ exports.BooleanSchema = BooleanSchema;
  * enabledSchema.parse('true') // throws - strings not accepted
  * ```
  */
-exports.boolean = (0, memoize_js_1.memoizedOptions)(function () {
+export const boolean = /*#__PURE__*/ memoizedOptions(function () {
     return new BooleanSchema();
 });
 //# sourceMappingURL=boolean.js.map

package/dist/schema/boolean.js.map

@@ -1 +1 @@
-{"version":3,"file":"boolean.js","sourceRoot":"","sources":["../../src/schema/boolean.ts"],"names":[],"mappings":";;;AAAA,wCAAsD;AACtD,mDAAoD;AAEpD;;;;;;;;;;;;;GAaG;AACH,MAAa,aAAc,SAAQ,gBAAe;IACvC,IAAI,GAAG,SAAkB,CAAA;IAElC,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,OAAO,KAAK,KAAK,SAAS,EAAE,CAAC;YAC/B,OAAO,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;QAC3B,CAAC;QAED,OAAO,GAAG,CAAC,mBAAmB,CAAC,KAAK,EAAE,SAAS,CAAC,CAAA;IAClD,CAAC;CACF;AAVD,sCAUC;AAED;;;;;;;;;;;;;GAaG;AACU,QAAA,OAAO,GAAiB,IAAA,4BAAe,EAAC;IACnD,OAAO,IAAI,aAAa,EAAE,CAAA;AAC5B,CAAC,CAAC,CAAA","sourcesContent":["import { Schema, ValidationContext } from '../core.js'\nimport { memoizedOptions } from '../util/memoize.js'\n\n/**\n * Schema for validating boolean values.\n *\n * Only accepts JavaScript `true` or `false` values. Does not perform\n * any coercion from strings or numbers.\n *\n * @example\n * ```ts\n * const schema = new BooleanSchema()\n * schema.validate(true)  // success\n * schema.validate(false) // success\n * schema.validate('true') // fails - no string coercion\n * ```\n */\nexport class BooleanSchema extends Schema<boolean> {\n  readonly type = 'boolean' as const\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (typeof input === 'boolean') {\n      return ctx.success(input)\n    }\n\n    return ctx.issueUnexpectedType(input, 'boolean')\n  }\n}\n\n/**\n * Creates a boolean schema that validates true/false values.\n *\n * @returns A new {@link BooleanSchema} instance\n *\n * @example\n * ```ts\n * const enabledSchema = l.boolean()\n *\n * enabledSchema.parse(true)   // true\n * enabledSchema.parse(false)  // false\n * enabledSchema.parse('true') // throws - strings not accepted\n * ```\n */\nexport const boolean = /*#__PURE__*/ memoizedOptions(function () {\n  return new BooleanSchema()\n})\n"]}
+{"version":3,"file":"boolean.js","sourceRoot":"","sources":["../../src/schema/boolean.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAqB,MAAM,YAAY,CAAA;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAEpD;;;;;;;;;;;;;GAaG;AACH,MAAM,OAAO,aAAc,SAAQ,MAAe;IAAlD;;QACW,SAAI,GAAG,SAAkB,CAAA;IASpC,CAAC;IAPC,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,OAAO,KAAK,KAAK,SAAS,EAAE,CAAC;YAC/B,OAAO,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;QAC3B,CAAC;QAED,OAAO,GAAG,CAAC,mBAAmB,CAAC,KAAK,EAAE,SAAS,CAAC,CAAA;IAClD,CAAC;CACF;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,aAAa,CAAC,eAAe,CAAC;IACnD,OAAO,IAAI,aAAa,EAAE,CAAA;AAC5B,CAAC,CAAC,CAAA","sourcesContent":["import { Schema, ValidationContext } from '../core.js'\nimport { memoizedOptions } from '../util/memoize.js'\n\n/**\n * Schema for validating boolean values.\n *\n * Only accepts JavaScript `true` or `false` values. Does not perform\n * any coercion from strings or numbers.\n *\n * @example\n * ```ts\n * const schema = new BooleanSchema()\n * schema.validate(true)  // success\n * schema.validate(false) // success\n * schema.validate('true') // fails - no string coercion\n * ```\n */\nexport class BooleanSchema extends Schema<boolean> {\n  readonly type = 'boolean' as const\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (typeof input === 'boolean') {\n      return ctx.success(input)\n    }\n\n    return ctx.issueUnexpectedType(input, 'boolean')\n  }\n}\n\n/**\n * Creates a boolean schema that validates true/false values.\n *\n * @returns A new {@link BooleanSchema} instance\n *\n * @example\n * ```ts\n * const enabledSchema = l.boolean()\n *\n * enabledSchema.parse(true)   // true\n * enabledSchema.parse(false)  // false\n * enabledSchema.parse('true') // throws - strings not accepted\n * ```\n */\nexport const boolean = /*#__PURE__*/ memoizedOptions(function () {\n  return new BooleanSchema()\n})\n"]}

package/dist/schema/bytes.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.bytes = exports.BytesSchema = void 0;
-const lex_data_1 = require("@atproto/lex-data");
-const core_js_1 = require("../core.js");
-const memoize_js_1 = require("../util/memoize.js");
+import { asUint8Array, ifUint8Array } from '@atproto/lex-data';
+import { Schema } from '../core.js';
+import { memoizedOptions } from '../util/memoize.js';
 /**
  * Schema for validating binary data as Uint8Array with optional length constraints.
  *
@@ -16,16 +13,15 @@ const memoize_js_1 = require("../util/memoize.js");
  * const result = schema.validate(new Uint8Array([1, 2, 3]))
  * ```
  */
-class BytesSchema extends core_js_1.Schema {
-    options;
-    type = 'bytes';
+export class BytesSchema extends Schema {
     constructor(options = {}) {
         super();
         this.options = options;
+        this.type = 'bytes';
     }
     validateInContext(input, ctx) {
         // In "parse" mode, coerce different binary formats into Uint8Array
-        const bytes = ctx.options.mode === 'parse' ? (0, lex_data_1.asUint8Array)(input) : (0, lex_data_1.ifUint8Array)(input);
+        const bytes = ctx.options.mode === 'parse' ? asUint8Array(input) : ifUint8Array(input);
         if (!bytes) {
             return ctx.issueUnexpectedType(input, 'bytes');
         }
@@ -40,7 +36,6 @@ class BytesSchema extends core_js_1.Schema {
         return ctx.success(bytes);
     }
 }
-exports.BytesSchema = BytesSchema;
 /**
  * Creates a bytes schema for validating binary data with optional length constraints.
  *
@@ -61,7 +56,7 @@ exports.BytesSchema = BytesSchema;
  * const hashSchema = l.bytes({ minLength: 32, maxLength: 32 }) // Exactly 32 bytes
  * ```
  */
-exports.bytes = (0, memoize_js_1.memoizedOptions)(function (options) {
+export const bytes = /*#__PURE__*/ memoizedOptions(function (options) {
     return new BytesSchema(options);
 });
 //# sourceMappingURL=bytes.js.map

package/dist/schema/bytes.js.map

@@ -1 +1 @@
-{"version":3,"file":"bytes.js","sourceRoot":"","sources":["../../src/schema/bytes.ts"],"names":[],"mappings":";;;AAAA,gDAA8D;AAC9D,wCAAsD;AACtD,mDAAoD;AAapD;;;;;;;;;;;GAWG;AACH,MAAa,WAAY,SAAQ,gBAAkB;IAG5B;IAFZ,IAAI,GAAG,OAAgB,CAAA;IAEhC,YAAqB,UAA8B,EAAE;QACnD,KAAK,EAAE,CAAA;QADY,YAAO,GAAP,OAAO,CAAyB;IAErD,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,mEAAmE;QACnE,MAAM,KAAK,GACT,GAAG,CAAC,OAAO,CAAC,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,IAAA,uBAAY,EAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAA,uBAAY,EAAC,KAAK,CAAC,CAAA;QAC1E,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,OAAO,GAAG,CAAC,mBAAmB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAA;QAChD,CAAC;QAED,MAAM,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC,OAAO,CAAA;QAClC,IAAI,SAAS,IAAI,IAAI,IAAI,KAAK,CAAC,MAAM,GAAG,SAAS,EAAE,CAAC;YAClD,OAAO,GAAG,CAAC,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;QACnE,CAAC;QAED,MAAM,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC,OAAO,CAAA;QAClC,IAAI,SAAS,IAAI,IAAI,IAAI,KAAK,CAAC,MAAM,GAAG,SAAS,EAAE,CAAC;YAClD,OAAO,GAAG,CAAC,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;QACjE,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;IAC3B,CAAC;CACF;AA3BD,kCA2BC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACU,QAAA,KAAK,GAAiB,IAAA,4BAAe,EAAC,UACjD,OAA4B;IAE5B,OAAO,IAAI,WAAW,CAAC,OAAO,CAAC,CAAA;AACjC,CAAC,CAAC,CAAA","sourcesContent":["import { asUint8Array, ifUint8Array } from '@atproto/lex-data'\nimport { Schema, ValidationContext } from '../core.js'\nimport { memoizedOptions } from '../util/memoize.js'\n\n/**\n * Configuration options for bytes schema validation.\n *\n * @property minLength - Minimum length in bytes\n * @property maxLength - Maximum length in bytes\n */\nexport type BytesSchemaOptions = {\n  minLength?: number\n  maxLength?: number\n}\n\n/**\n * Schema for validating binary data as Uint8Array with optional length constraints.\n *\n * In \"parse\" mode, coerces various binary formats (Buffer, ArrayBuffer, etc.)\n * into Uint8Array. In \"validate\" mode, only accepts Uint8Array directly.\n *\n * @example\n * ```ts\n * const schema = new BytesSchema({ maxLength: 1024 })\n * const result = schema.validate(new Uint8Array([1, 2, 3]))\n * ```\n */\nexport class BytesSchema extends Schema<Uint8Array> {\n  readonly type = 'bytes' as const\n\n  constructor(readonly options: BytesSchemaOptions = {}) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    // In \"parse\" mode, coerce different binary formats into Uint8Array\n    const bytes =\n      ctx.options.mode === 'parse' ? asUint8Array(input) : ifUint8Array(input)\n    if (!bytes) {\n      return ctx.issueUnexpectedType(input, 'bytes')\n    }\n\n    const { minLength } = this.options\n    if (minLength != null && bytes.length < minLength) {\n      return ctx.issueTooSmall(bytes, 'bytes', minLength, bytes.length)\n    }\n\n    const { maxLength } = this.options\n    if (maxLength != null && bytes.length > maxLength) {\n      return ctx.issueTooBig(bytes, 'bytes', maxLength, bytes.length)\n    }\n\n    return ctx.success(bytes)\n  }\n}\n\n/**\n * Creates a bytes schema for validating binary data with optional length constraints.\n *\n * Validates Uint8Array values and can coerce other binary formats in parse mode.\n *\n * @param options - Optional configuration for minimum and maximum byte length\n * @returns A new {@link BytesSchema} instance\n *\n * @example\n * ```ts\n * // Basic bytes schema\n * const dataSchema = l.bytes()\n *\n * // With size constraints\n * const avatarSchema = l.bytes({ maxLength: 1000000 }) // 1MB max\n *\n * // With minimum size\n * const hashSchema = l.bytes({ minLength: 32, maxLength: 32 }) // Exactly 32 bytes\n * ```\n */\nexport const bytes = /*#__PURE__*/ memoizedOptions(function (\n  options?: BytesSchemaOptions,\n) {\n  return new BytesSchema(options)\n})\n"]}
+{"version":3,"file":"bytes.js","sourceRoot":"","sources":["../../src/schema/bytes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAC9D,OAAO,EAAE,MAAM,EAAqB,MAAM,YAAY,CAAA;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAapD;;;;;;;;;;;GAWG;AACH,MAAM,OAAO,WAAY,SAAQ,MAAkB;IAGjD,YAAqB,UAA8B,EAAE;QACnD,KAAK,EAAE,CAAA;QADY,YAAO,GAAP,OAAO,CAAyB;QAF5C,SAAI,GAAG,OAAgB,CAAA;IAIhC,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,mEAAmE;QACnE,MAAM,KAAK,GACT,GAAG,CAAC,OAAO,CAAC,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,KAAK,CAAC,CAAA;QAC1E,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,OAAO,GAAG,CAAC,mBAAmB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAA;QAChD,CAAC;QAED,MAAM,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC,OAAO,CAAA;QAClC,IAAI,SAAS,IAAI,IAAI,IAAI,KAAK,CAAC,MAAM,GAAG,SAAS,EAAE,CAAC;YAClD,OAAO,GAAG,CAAC,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;QACnE,CAAC;QAED,MAAM,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC,OAAO,CAAA;QAClC,IAAI,SAAS,IAAI,IAAI,IAAI,KAAK,CAAC,MAAM,GAAG,SAAS,EAAE,CAAC;YAClD,OAAO,GAAG,CAAC,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;QACjE,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;IAC3B,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,aAAa,CAAC,eAAe,CAAC,UACjD,OAA4B;IAE5B,OAAO,IAAI,WAAW,CAAC,OAAO,CAAC,CAAA;AACjC,CAAC,CAAC,CAAA","sourcesContent":["import { asUint8Array, ifUint8Array } from '@atproto/lex-data'\nimport { Schema, ValidationContext } from '../core.js'\nimport { memoizedOptions } from '../util/memoize.js'\n\n/**\n * Configuration options for bytes schema validation.\n *\n * @property minLength - Minimum length in bytes\n * @property maxLength - Maximum length in bytes\n */\nexport type BytesSchemaOptions = {\n  minLength?: number\n  maxLength?: number\n}\n\n/**\n * Schema for validating binary data as Uint8Array with optional length constraints.\n *\n * In \"parse\" mode, coerces various binary formats (Buffer, ArrayBuffer, etc.)\n * into Uint8Array. In \"validate\" mode, only accepts Uint8Array directly.\n *\n * @example\n * ```ts\n * const schema = new BytesSchema({ maxLength: 1024 })\n * const result = schema.validate(new Uint8Array([1, 2, 3]))\n * ```\n */\nexport class BytesSchema extends Schema<Uint8Array> {\n  readonly type = 'bytes' as const\n\n  constructor(readonly options: BytesSchemaOptions = {}) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    // In \"parse\" mode, coerce different binary formats into Uint8Array\n    const bytes =\n      ctx.options.mode === 'parse' ? asUint8Array(input) : ifUint8Array(input)\n    if (!bytes) {\n      return ctx.issueUnexpectedType(input, 'bytes')\n    }\n\n    const { minLength } = this.options\n    if (minLength != null && bytes.length < minLength) {\n      return ctx.issueTooSmall(bytes, 'bytes', minLength, bytes.length)\n    }\n\n    const { maxLength } = this.options\n    if (maxLength != null && bytes.length > maxLength) {\n      return ctx.issueTooBig(bytes, 'bytes', maxLength, bytes.length)\n    }\n\n    return ctx.success(bytes)\n  }\n}\n\n/**\n * Creates a bytes schema for validating binary data with optional length constraints.\n *\n * Validates Uint8Array values and can coerce other binary formats in parse mode.\n *\n * @param options - Optional configuration for minimum and maximum byte length\n * @returns A new {@link BytesSchema} instance\n *\n * @example\n * ```ts\n * // Basic bytes schema\n * const dataSchema = l.bytes()\n *\n * // With size constraints\n * const avatarSchema = l.bytes({ maxLength: 1000000 }) // 1MB max\n *\n * // With minimum size\n * const hashSchema = l.bytes({ minLength: 32, maxLength: 32 }) // Exactly 32 bytes\n * ```\n */\nexport const bytes = /*#__PURE__*/ memoizedOptions(function (\n  options?: BytesSchemaOptions,\n) {\n  return new BytesSchema(options)\n})\n"]}

package/dist/schema/cid.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cid = exports.CidSchema = void 0;
-const lex_data_1 = require("@atproto/lex-data");
-const core_js_1 = require("../core.js");
-const memoize_js_1 = require("../util/memoize.js");
+import { isCid } from '@atproto/lex-data';
+import { Schema } from '../core.js';
+import { memoizedOptions } from '../util/memoize.js';
 /**
  * Schema for validating Content Identifiers (CIDs).
  *
@@ -19,21 +16,19 @@ const memoize_js_1 = require("../util/memoize.js");
  * const result = schema.validate(someCid)
  * ```
  */
-class CidSchema extends core_js_1.Schema {
-    options;
-    type = 'cid';
+export class CidSchema extends Schema {
     constructor(options) {
         super();
         this.options = options;
+        this.type = 'cid';
     }
     validateInContext(input, ctx) {
-        if (!(0, lex_data_1.isCid)(input, this.options)) {
+        if (!isCid(input, this.options)) {
             return ctx.issueUnexpectedType(input, 'cid');
         }
         return ctx.success(input);
     }
 }
-exports.CidSchema = CidSchema;
 /**
  * Creates a CID schema for validating Content Identifiers.
  *
@@ -52,7 +47,7 @@ exports.CidSchema = CidSchema;
  * const result = cidSchema.validate(blobRef.ref)
  * ```
  */
-exports.cid = (0, memoize_js_1.memoizedOptions)(function (options) {
+export const cid = /*#__PURE__*/ memoizedOptions(function (options) {
     return new CidSchema(options);
 });
 //# sourceMappingURL=cid.js.map

package/dist/schema/cid.js.map

@@ -1 +1 @@
-{"version":3,"file":"cid.js","sourceRoot":"","sources":["../../src/schema/cid.ts"],"names":[],"mappings":";;;AAAA,gDAAgF;AAChF,wCAAsD;AACtD,mDAAoD;AAWpD;;;;;;;;;;;;;;GAcG;AACH,MAAa,SAEX,SAAQ,gBAAiC;IAGpB;IAFZ,IAAI,GAAG,KAAc,CAAA;IAE9B,YAAqB,OAAkB;QACrC,KAAK,EAAE,CAAA;QADY,YAAO,GAAP,OAAO,CAAW;IAEvC,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,CAAC,IAAA,gBAAK,EAAC,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;YAChC,OAAO,GAAG,CAAC,mBAAmB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAA;QAC9C,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;IAC3B,CAAC;CACF;AAhBD,8BAgBC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACU,QAAA,GAAG,GAAiB,IAAA,4BAAe,EAAC,UAE/C,OAAW;IACX,OAAO,IAAI,SAAS,CAAC,OAAO,CAAC,CAAA;AAC/B,CAAC,CAAC,CAAA","sourcesContent":["import { CheckCidOptions, Cid, InferCheckedCid, isCid } from '@atproto/lex-data'\nimport { Schema, ValidationContext } from '../core.js'\nimport { memoizedOptions } from '../util/memoize.js'\n\nexport type { Cid }\n\n/**\n * Configuration options for CID schema validation.\n *\n * @see CheckCidOptions from @atproto/lex-data for available options\n */\nexport type CidSchemaOptions = CheckCidOptions\n\n/**\n * Schema for validating Content Identifiers (CIDs).\n *\n * CIDs are self-describing content-addressed identifiers used in AT Protocol\n * to reference data by its cryptographic hash. This schema validates that\n * the input is a valid CID object.\n *\n * @template TOptions - The configuration options type\n *\n * @example\n * ```ts\n * const schema = new CidSchema()\n * const result = schema.validate(someCid)\n * ```\n */\nexport class CidSchema<\n  const TOptions extends CidSchemaOptions = { flavor: undefined },\n> extends Schema<InferCheckedCid<TOptions>> {\n  readonly type = 'cid' as const\n\n  constructor(readonly options?: TOptions) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (!isCid(input, this.options)) {\n      return ctx.issueUnexpectedType(input, 'cid')\n    }\n\n    return ctx.success(input)\n  }\n}\n\n/**\n * Creates a CID schema for validating Content Identifiers.\n *\n * CIDs are used throughout AT Protocol to reference content by its hash.\n * This is commonly used for referencing blobs, commits, and other data.\n *\n * @param options - Optional configuration for CID validation\n * @returns A new {@link CidSchema} instance\n *\n * @example\n * ```ts\n * // Basic CID validation\n * const cidSchema = l.cid()\n *\n * // Validate a CID from a blob reference\n * const result = cidSchema.validate(blobRef.ref)\n * ```\n */\nexport const cid = /*#__PURE__*/ memoizedOptions(function <\n  O extends CidSchemaOptions = NonNullable<unknown>,\n>(options?: O) {\n  return new CidSchema(options)\n})\n"]}
+{"version":3,"file":"cid.js","sourceRoot":"","sources":["../../src/schema/cid.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyC,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAChF,OAAO,EAAE,MAAM,EAAqB,MAAM,YAAY,CAAA;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAWpD;;;;;;;;;;;;;;GAcG;AACH,MAAM,OAAO,SAEX,SAAQ,MAAiC;IAGzC,YAAqB,OAAkB;QACrC,KAAK,EAAE,CAAA;QADY,YAAO,GAAP,OAAO,CAAW;QAF9B,SAAI,GAAG,KAAc,CAAA;IAI9B,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;YAChC,OAAO,GAAG,CAAC,mBAAmB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAA;QAC9C,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;IAC3B,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,GAAG,GAAG,aAAa,CAAC,eAAe,CAAC,UAE/C,OAAW;IACX,OAAO,IAAI,SAAS,CAAC,OAAO,CAAC,CAAA;AAC/B,CAAC,CAAC,CAAA","sourcesContent":["import { CheckCidOptions, Cid, InferCheckedCid, isCid } from '@atproto/lex-data'\nimport { Schema, ValidationContext } from '../core.js'\nimport { memoizedOptions } from '../util/memoize.js'\n\nexport type { Cid }\n\n/**\n * Configuration options for CID schema validation.\n *\n * @see CheckCidOptions from @atproto/lex-data for available options\n */\nexport type CidSchemaOptions = CheckCidOptions\n\n/**\n * Schema for validating Content Identifiers (CIDs).\n *\n * CIDs are self-describing content-addressed identifiers used in AT Protocol\n * to reference data by its cryptographic hash. This schema validates that\n * the input is a valid CID object.\n *\n * @template TOptions - The configuration options type\n *\n * @example\n * ```ts\n * const schema = new CidSchema()\n * const result = schema.validate(someCid)\n * ```\n */\nexport class CidSchema<\n  const TOptions extends CidSchemaOptions = { flavor: undefined },\n> extends Schema<InferCheckedCid<TOptions>> {\n  readonly type = 'cid' as const\n\n  constructor(readonly options?: TOptions) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (!isCid(input, this.options)) {\n      return ctx.issueUnexpectedType(input, 'cid')\n    }\n\n    return ctx.success(input)\n  }\n}\n\n/**\n * Creates a CID schema for validating Content Identifiers.\n *\n * CIDs are used throughout AT Protocol to reference content by its hash.\n * This is commonly used for referencing blobs, commits, and other data.\n *\n * @param options - Optional configuration for CID validation\n * @returns A new {@link CidSchema} instance\n *\n * @example\n * ```ts\n * // Basic CID validation\n * const cidSchema = l.cid()\n *\n * // Validate a CID from a blob reference\n * const result = cidSchema.validate(blobRef.ref)\n * ```\n */\nexport const cid = /*#__PURE__*/ memoizedOptions(function <\n  O extends CidSchemaOptions = NonNullable<unknown>,\n>(options?: O) {\n  return new CidSchema(options)\n})\n"]}

package/dist/schema/custom.js

@@ -1,8 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CustomSchema = void 0;
-exports.custom = custom;
-const core_js_1 = require("../core.js");
+import { IssueCustom, Schema } from '../core.js';
 /**
  * Schema with a custom validation function.
  *
@@ -20,26 +16,22 @@ const core_js_1 = require("../core.js");
  * )
  * ```
  */
-class CustomSchema extends core_js_1.Schema {
-    assertion;
-    message;
-    path;
-    type = 'custom';
+export class CustomSchema extends Schema {
     constructor(assertion, message, path) {
         super();
         this.assertion = assertion;
         this.message = message;
         this.path = path;
+        this.type = 'custom';
     }
     validateInContext(input, ctx) {
         if (!this.assertion.call(null, input, ctx)) {
             const path = ctx.concatPath(this.path);
-            return ctx.issue(new core_js_1.IssueCustom(path, input, this.message));
+            return ctx.issue(new IssueCustom(path, input, this.message));
         }
         return ctx.success(input);
     }
 }
-exports.CustomSchema = CustomSchema;
 /**
  * Creates a custom schema with a user-defined validation function.
  *
@@ -78,7 +70,7 @@ exports.CustomSchema = CustomSchema;
  * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
-function custom(assertion, message, path) {
+export function custom(assertion, message, path) {
     return new CustomSchema(assertion, message, path);
 }
 //# sourceMappingURL=custom.js.map

package/dist/schema/custom.js.map

@@ -1 +1 @@
-{"version":3,"file":"custom.js","sourceRoot":"","sources":["../../src/schema/custom.ts"],"names":[],"mappings":";;;AAmGA,wBAMC;AAzGD,wCAA0E;AAwB1E;;;;;;;;;;;;;;;;GAgBG;AACH,MAAa,YAAmC,SAAQ,gBAAc;IAIjD;IACA;IACA;IALV,IAAI,GAAG,QAAiB,CAAA;IAEjC,YACmB,SAAkC,EAClC,OAAe,EACf,IAA2C;QAE5D,KAAK,EAAE,CAAA;QAJU,cAAS,GAAT,SAAS,CAAyB;QAClC,YAAO,GAAP,OAAO,CAAQ;QACf,SAAI,GAAJ,IAAI,CAAuC;IAG9D,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,GAAG,CAAC,EAAE,CAAC;YAC3C,MAAM,IAAI,GAAG,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;YACtC,OAAO,GAAG,CAAC,KAAK,CAAC,IAAI,qBAAW,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAA;QAC9D,CAAC;QACD,OAAO,GAAG,CAAC,OAAO,CAAC,KAAe,CAAC,CAAA;IACrC,CAAC;CACF;AAlBD,oCAkBC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAwB;AACxB,SAAgB,MAAM,CACpB,SAAkC,EAClC,OAAe,EACf,IAA2C;IAE3C,OAAO,IAAI,YAAY,CAAS,SAAS,EAAE,OAAO,EAAE,IAAI,CAAC,CAAA;AAC3D,CAAC","sourcesContent":["import { Issue, IssueCustom, Schema, ValidationContext } from '../core.js'\n\n/**\n * Context object provided to custom assertion functions.\n *\n * @property path - Current validation path as an array of property keys\n * @property addIssue - Function to add additional validation issues\n */\nexport type CustomAssertionContext = {\n  path: PropertyKey[]\n  addIssue(issue: Issue): void\n}\n\n/**\n * Type guard function for custom schema validation.\n *\n * @template TValue - The type to validate/narrow to\n */\nexport type CustomAssertion<TValue> = (\n  this: null,\n  input: unknown,\n  ctx: CustomAssertionContext,\n) => input is TValue\n\n/**\n * Schema with a custom validation function.\n *\n * Allows defining completely custom validation logic using a type guard\n * assertion function. The function receives the input and validation context,\n * and must return whether the input is valid.\n *\n * @template TValue - The validated output type\n *\n * @example\n * ```ts\n * const schema = new CustomSchema(\n *   (input): input is Date => input instanceof Date,\n *   'Expected a Date instance'\n * )\n * ```\n */\nexport class CustomSchema<out TValue = unknown> extends Schema<TValue> {\n  readonly type = 'custom' as const\n\n  constructor(\n    private readonly assertion: CustomAssertion<TValue>,\n    private readonly message: string,\n    private readonly path?: PropertyKey | readonly PropertyKey[],\n  ) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (!this.assertion.call(null, input, ctx)) {\n      const path = ctx.concatPath(this.path)\n      return ctx.issue(new IssueCustom(path, input, this.message))\n    }\n    return ctx.success(input as TValue)\n  }\n}\n\n/**\n * Creates a custom schema with a user-defined validation function.\n *\n * Use this when the built-in schemas don't cover your validation needs.\n * The assertion function must be a type guard that narrows the input type.\n *\n * @param assertion - Type guard function that validates the input\n * @param message - Error message when validation fails\n * @param path - Optional path to associate with validation errors\n * @returns A new {@link CustomSchema} instance\n *\n * @example\n * ```ts\n * // Validate Date instances\n * const dateSchema = l.custom(\n *   (input): input is Date => input instanceof Date && !isNaN(input.getTime()),\n *   'Expected a valid Date'\n * )\n *\n * // Validate specific object shape\n * const pointSchema = l.custom(\n *   (input): input is { x: number; y: number } =>\n *     typeof input === 'object' &&\n *     input !== null &&\n *     typeof (input as any).x === 'number' &&\n *     typeof (input as any).y === 'number',\n *   'Expected a point with x and y coordinates'\n * )\n *\n * // With custom path\n * const validConfig = l.custom(\n *   (input): input is Config => validateConfig(input),\n *   'Invalid configuration',\n *   ['config']\n * )\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function custom<TValue>(\n  assertion: CustomAssertion<TValue>,\n  message: string,\n  path?: PropertyKey | readonly PropertyKey[],\n) {\n  return new CustomSchema<TValue>(assertion, message, path)\n}\n"]}
+{"version":3,"file":"custom.js","sourceRoot":"","sources":["../../src/schema/custom.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,WAAW,EAAE,MAAM,EAAqB,MAAM,YAAY,CAAA;AAwB1E;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,OAAO,YAAmC,SAAQ,MAAc;IAGpE,YACmB,SAAkC,EAClC,OAAe,EACf,IAA2C;QAE5D,KAAK,EAAE,CAAA;QAJU,cAAS,GAAT,SAAS,CAAyB;QAClC,YAAO,GAAP,OAAO,CAAQ;QACf,SAAI,GAAJ,IAAI,CAAuC;QALrD,SAAI,GAAG,QAAiB,CAAA;IAQjC,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,GAAG,CAAC,EAAE,CAAC;YAC3C,MAAM,IAAI,GAAG,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;YACtC,OAAO,GAAG,CAAC,KAAK,CAAC,IAAI,WAAW,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAA;QAC9D,CAAC;QACD,OAAO,GAAG,CAAC,OAAO,CAAC,KAAe,CAAC,CAAA;IACrC,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAwB;AACxB,MAAM,UAAU,MAAM,CACpB,SAAkC,EAClC,OAAe,EACf,IAA2C;IAE3C,OAAO,IAAI,YAAY,CAAS,SAAS,EAAE,OAAO,EAAE,IAAI,CAAC,CAAA;AAC3D,CAAC","sourcesContent":["import { Issue, IssueCustom, Schema, ValidationContext } from '../core.js'\n\n/**\n * Context object provided to custom assertion functions.\n *\n * @property path - Current validation path as an array of property keys\n * @property addIssue - Function to add additional validation issues\n */\nexport type CustomAssertionContext = {\n  path: PropertyKey[]\n  addIssue(issue: Issue): void\n}\n\n/**\n * Type guard function for custom schema validation.\n *\n * @template TValue - The type to validate/narrow to\n */\nexport type CustomAssertion<TValue> = (\n  this: null,\n  input: unknown,\n  ctx: CustomAssertionContext,\n) => input is TValue\n\n/**\n * Schema with a custom validation function.\n *\n * Allows defining completely custom validation logic using a type guard\n * assertion function. The function receives the input and validation context,\n * and must return whether the input is valid.\n *\n * @template TValue - The validated output type\n *\n * @example\n * ```ts\n * const schema = new CustomSchema(\n *   (input): input is Date => input instanceof Date,\n *   'Expected a Date instance'\n * )\n * ```\n */\nexport class CustomSchema<out TValue = unknown> extends Schema<TValue> {\n  readonly type = 'custom' as const\n\n  constructor(\n    private readonly assertion: CustomAssertion<TValue>,\n    private readonly message: string,\n    private readonly path?: PropertyKey | readonly PropertyKey[],\n  ) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (!this.assertion.call(null, input, ctx)) {\n      const path = ctx.concatPath(this.path)\n      return ctx.issue(new IssueCustom(path, input, this.message))\n    }\n    return ctx.success(input as TValue)\n  }\n}\n\n/**\n * Creates a custom schema with a user-defined validation function.\n *\n * Use this when the built-in schemas don't cover your validation needs.\n * The assertion function must be a type guard that narrows the input type.\n *\n * @param assertion - Type guard function that validates the input\n * @param message - Error message when validation fails\n * @param path - Optional path to associate with validation errors\n * @returns A new {@link CustomSchema} instance\n *\n * @example\n * ```ts\n * // Validate Date instances\n * const dateSchema = l.custom(\n *   (input): input is Date => input instanceof Date && !isNaN(input.getTime()),\n *   'Expected a valid Date'\n * )\n *\n * // Validate specific object shape\n * const pointSchema = l.custom(\n *   (input): input is { x: number; y: number } =>\n *     typeof input === 'object' &&\n *     input !== null &&\n *     typeof (input as any).x === 'number' &&\n *     typeof (input as any).y === 'number',\n *   'Expected a point with x and y coordinates'\n * )\n *\n * // With custom path\n * const validConfig = l.custom(\n *   (input): input is Config => validateConfig(input),\n *   'Invalid configuration',\n *   ['config']\n * )\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function custom<TValue>(\n  assertion: CustomAssertion<TValue>,\n  message: string,\n  path?: PropertyKey | readonly PropertyKey[],\n) {\n  return new CustomSchema<TValue>(assertion, message, path)\n}\n"]}

package/dist/schema/dict.js

@@ -1,9 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DictSchema = void 0;
-exports.dict = dict;
-const lex_data_1 = require("@atproto/lex-data");
-const core_js_1 = require("../core.js");
+import { isPlainObject } from '@atproto/lex-data';
+import { Schema, } from '../core.js';
 /**
  * Schema for validating dictionary/map-like objects with dynamic keys.
  *
@@ -24,17 +20,15 @@ const core_js_1 = require("../core.js");
  * const result = schema.validate({ a: 1, b: 2, c: 3 })
  * ```
  */
-class DictSchema extends core_js_1.Schema {
-    keySchema;
-    valueSchema;
-    type = 'dict';
+export class DictSchema extends Schema {
     constructor(keySchema, valueSchema) {
         super();
         this.keySchema = keySchema;
         this.valueSchema = valueSchema;
+        this.type = 'dict';
     }
     validateInContext(input, ctx, options) {
-        if (!(0, lex_data_1.isPlainObject)(input)) {
+        if (!isPlainObject(input)) {
             return ctx.issueUnexpectedType(input, 'dict');
         }
         let copy;
@@ -65,7 +59,6 @@ class DictSchema extends core_js_1.Schema {
         return ctx.success(copy ?? input);
     }
 }
-exports.DictSchema = DictSchema;
 /**
  * Creates a dictionary schema for validating map-like objects.
  *
@@ -96,7 +89,7 @@ exports.DictSchema = DictSchema;
  * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
-function dict(key, value) {
+export function dict(key, value) {
     return new DictSchema(key, value);
 }
 //# sourceMappingURL=dict.js.map

package/dist/schema/dict.js.map

@@ -1 +1 @@
-{"version":3,"file":"dict.js","sourceRoot":"","sources":["../../src/schema/dict.ts"],"names":[],"mappings":";;;AAoHA,oBAKC;AAzHD,gDAAiD;AACjD,wCAMmB;AAEnB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAa,UAGX,SAAQ,gBAGT;IAIY;IACA;IAJF,IAAI,GAAG,MAAe,CAAA;IAE/B,YACW,SAAe,EACf,WAAmB;QAE5B,KAAK,EAAE,CAAA;QAHE,cAAS,GAAT,SAAS,CAAM;QACf,gBAAW,GAAX,WAAW,CAAQ;IAG9B,CAAC;IAED,iBAAiB,CACf,KAAc,EACd,GAAsB,EACtB,OAAuD;QAEvD,IAAI,CAAC,IAAA,wBAAa,EAAC,KAAK,CAAC,EAAE,CAAC;YAC1B,OAAO,GAAG,CAAC,mBAAmB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAA;QAC/C,CAAC;QAED,IAAI,IAAyC,CAAA;QAE7C,KAAK,MAAM,GAAG,IAAI,KAAK,EAAE,CAAC;YACxB,IAAI,OAAO,EAAE,WAAW,EAAE,GAAG,CAAC,GAAG,CAAC;gBAAE,SAAQ;YAE5C,MAAM,SAAS,GAAG,GAAG,CAAC,QAAQ,CAAC,GAAG,EAAE,IAAI,CAAC,SAAS,CAAC,CAAA;YACnD,IAAI,CAAC,SAAS,CAAC,OAAO;gBAAE,OAAO,SAAS,CAAA;YACxC,IAAI,SAAS,CAAC,KAAK,KAAK,GAAG,EAAE,CAAC;gBAC5B,mEAAmE;gBACnE,uEAAuE;gBACvE,6DAA6D;gBAC7D,OAAO,GAAG,CAAC,gBAAgB,CAAC,KAAK,EAAE,GAAG,CAAC,CAAA;YACzC,CAAC;YAED,MAAM,WAAW,GAAG,GAAG,CAAC,aAAa,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,CAAC,WAAW,CAAC,CAAA;YACnE,IAAI,CAAC,WAAW,CAAC,OAAO;gBAAE,OAAO,WAAW,CAAA;YAE5C,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,WAAW,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;gBAC9C,IAAI,GAAG,CAAC,OAAO,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;oBACpC,sEAAsE;oBACtE,OAAO,GAAG,CAAC,yBAAyB,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAA;gBACvE,CAAC;gBAED,IAAI,KAAK,EAAE,GAAG,KAAK,EAAE,CAAA;gBACrB,IAAI,CAAC,GAAG,CAAC,GAAG,WAAW,CAAC,KAAK,CAAA;YAC/B,CAAC;QACH,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,IAAI,IAAI,KAAK,CAAC,CAAA;IACnC,CAAC;CACF;AAvDD,gCAuDC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAwB;AACxB,SAAgB,IAAI,CAGlB,GAAS,EAAE,KAAa;IACxB,OAAO,IAAI,UAAU,CAAe,GAAG,EAAE,KAAK,CAAC,CAAA;AACjD,CAAC","sourcesContent":["import { isPlainObject } from '@atproto/lex-data'\nimport {\n  InferInput,\n  InferOutput,\n  Schema,\n  ValidationContext,\n  Validator,\n} from '../core.js'\n\n/**\n * Schema for validating dictionary/map-like objects with dynamic keys.\n *\n * Unlike `ObjectSchema` which validates a fixed set of properties, `DictSchema`\n * validates objects where any string key is allowed, with both keys and values\n * validated against their respective schemas.\n *\n * @note There is no dictionary in Lexicon schemas. This is a custom extension\n * to allow map-like objects when using the lex library programmatically (i.e.\n * not code generated from a lexicon schema).\n *\n * @template TKey - The validator type for dictionary keys (must validate strings)\n * @template TValue - The validator type for dictionary values\n *\n * @example\n * ```ts\n * const schema = new DictSchema(l.string(), l.integer())\n * const result = schema.validate({ a: 1, b: 2, c: 3 })\n * ```\n */\nexport class DictSchema<\n  const TKey extends Validator<string> = any,\n  const TValue extends Validator = any,\n> extends Schema<\n  Record<InferInput<TKey>, InferInput<TValue>>,\n  Record<InferInput<TKey>, InferOutput<TValue>>\n> {\n  readonly type = 'dict' as const\n\n  constructor(\n    readonly keySchema: TKey,\n    readonly valueSchema: TValue,\n  ) {\n    super()\n  }\n\n  validateInContext(\n    input: unknown,\n    ctx: ValidationContext,\n    options?: { ignoredKeys?: { has(k: string): boolean } },\n  ) {\n    if (!isPlainObject(input)) {\n      return ctx.issueUnexpectedType(input, 'dict')\n    }\n\n    let copy: undefined | Record<string, unknown>\n\n    for (const key in input) {\n      if (options?.ignoredKeys?.has(key)) continue\n\n      const keyResult = ctx.validate(key, this.keySchema)\n      if (!keyResult.success) return keyResult\n      if (keyResult.value !== key) {\n        // We can't safely \"move\" the key to a different name in the output\n        // object (because there may already be something there), so we issue a\n        // \"required key\" error if the key validation changes the key\n        return ctx.issueRequiredKey(input, key)\n      }\n\n      const valueResult = ctx.validateChild(input, key, this.valueSchema)\n      if (!valueResult.success) return valueResult\n\n      if (!Object.is(valueResult.value, input[key])) {\n        if (ctx.options.mode === 'validate') {\n          // In \"validate\" mode, we can't modify the input, so we issue an error\n          return ctx.issueInvalidPropertyValue(input, key, [valueResult.value])\n        }\n\n        copy ??= { ...input }\n        copy[key] = valueResult.value\n      }\n    }\n\n    return ctx.success(copy ?? input)\n  }\n}\n\n/**\n * Creates a dictionary schema for validating map-like objects.\n *\n * Validates objects where all keys match the key schema and all values\n * match the value schema. Useful for dynamic key-value mappings.\n *\n * @param key - Schema to validate each key (must be a string validator)\n * @param value - Schema to validate each value\n * @returns A new {@link DictSchema} instance\n *\n * @example\n * ```ts\n * // String to number mapping\n * const scoresSchema = l.dict(l.string(), l.integer())\n * scoresSchema.parse({ alice: 100, bob: 85 })\n *\n * // Constrained keys\n * const langSchema = l.dict(\n *   l.string({ minLength: 2, maxLength: 5 }), // Language codes\n *   l.string() // Translations\n * )\n *\n * // Complex values\n * const usersById = l.dict(\n *   l.string({ format: 'did' }),\n *   l.object({ name: l.string(), age: l.integer() })\n * )\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function dict<\n  const TKey extends Validator<string>,\n  const TValue extends Validator,\n>(key: TKey, value: TValue) {\n  return new DictSchema<TKey, TValue>(key, value)\n}\n"]}
+{"version":3,"file":"dict.js","sourceRoot":"","sources":["../../src/schema/dict.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AACjD,OAAO,EAGL,MAAM,GAGP,MAAM,YAAY,CAAA;AAEnB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,OAAO,UAGX,SAAQ,MAGT;IAGC,YACW,SAAe,EACf,WAAmB;QAE5B,KAAK,EAAE,CAAA;QAHE,cAAS,GAAT,SAAS,CAAM;QACf,gBAAW,GAAX,WAAW,CAAQ;QAJrB,SAAI,GAAG,MAAe,CAAA;IAO/B,CAAC;IAED,iBAAiB,CACf,KAAc,EACd,GAAsB,EACtB,OAAuD;QAEvD,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;YAC1B,OAAO,GAAG,CAAC,mBAAmB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAA;QAC/C,CAAC;QAED,IAAI,IAAyC,CAAA;QAE7C,KAAK,MAAM,GAAG,IAAI,KAAK,EAAE,CAAC;YACxB,IAAI,OAAO,EAAE,WAAW,EAAE,GAAG,CAAC,GAAG,CAAC;gBAAE,SAAQ;YAE5C,MAAM,SAAS,GAAG,GAAG,CAAC,QAAQ,CAAC,GAAG,EAAE,IAAI,CAAC,SAAS,CAAC,CAAA;YACnD,IAAI,CAAC,SAAS,CAAC,OAAO;gBAAE,OAAO,SAAS,CAAA;YACxC,IAAI,SAAS,CAAC,KAAK,KAAK,GAAG,EAAE,CAAC;gBAC5B,mEAAmE;gBACnE,uEAAuE;gBACvE,6DAA6D;gBAC7D,OAAO,GAAG,CAAC,gBAAgB,CAAC,KAAK,EAAE,GAAG,CAAC,CAAA;YACzC,CAAC;YAED,MAAM,WAAW,GAAG,GAAG,CAAC,aAAa,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,CAAC,WAAW,CAAC,CAAA;YACnE,IAAI,CAAC,WAAW,CAAC,OAAO;gBAAE,OAAO,WAAW,CAAA;YAE5C,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,WAAW,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;gBAC9C,IAAI,GAAG,CAAC,OAAO,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;oBACpC,sEAAsE;oBACtE,OAAO,GAAG,CAAC,yBAAyB,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAA;gBACvE,CAAC;gBAED,IAAI,KAAK,EAAE,GAAG,KAAK,EAAE,CAAA;gBACrB,IAAI,CAAC,GAAG,CAAC,GAAG,WAAW,CAAC,KAAK,CAAA;YAC/B,CAAC;QACH,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,IAAI,IAAI,KAAK,CAAC,CAAA;IACnC,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAwB;AACxB,MAAM,UAAU,IAAI,CAGlB,GAAS,EAAE,KAAa;IACxB,OAAO,IAAI,UAAU,CAAe,GAAG,EAAE,KAAK,CAAC,CAAA;AACjD,CAAC","sourcesContent":["import { isPlainObject } from '@atproto/lex-data'\nimport {\n  InferInput,\n  InferOutput,\n  Schema,\n  ValidationContext,\n  Validator,\n} from '../core.js'\n\n/**\n * Schema for validating dictionary/map-like objects with dynamic keys.\n *\n * Unlike `ObjectSchema` which validates a fixed set of properties, `DictSchema`\n * validates objects where any string key is allowed, with both keys and values\n * validated against their respective schemas.\n *\n * @note There is no dictionary in Lexicon schemas. This is a custom extension\n * to allow map-like objects when using the lex library programmatically (i.e.\n * not code generated from a lexicon schema).\n *\n * @template TKey - The validator type for dictionary keys (must validate strings)\n * @template TValue - The validator type for dictionary values\n *\n * @example\n * ```ts\n * const schema = new DictSchema(l.string(), l.integer())\n * const result = schema.validate({ a: 1, b: 2, c: 3 })\n * ```\n */\nexport class DictSchema<\n  const TKey extends Validator<string> = any,\n  const TValue extends Validator = any,\n> extends Schema<\n  Record<InferInput<TKey>, InferInput<TValue>>,\n  Record<InferInput<TKey>, InferOutput<TValue>>\n> {\n  readonly type = 'dict' as const\n\n  constructor(\n    readonly keySchema: TKey,\n    readonly valueSchema: TValue,\n  ) {\n    super()\n  }\n\n  validateInContext(\n    input: unknown,\n    ctx: ValidationContext,\n    options?: { ignoredKeys?: { has(k: string): boolean } },\n  ) {\n    if (!isPlainObject(input)) {\n      return ctx.issueUnexpectedType(input, 'dict')\n    }\n\n    let copy: undefined | Record<string, unknown>\n\n    for (const key in input) {\n      if (options?.ignoredKeys?.has(key)) continue\n\n      const keyResult = ctx.validate(key, this.keySchema)\n      if (!keyResult.success) return keyResult\n      if (keyResult.value !== key) {\n        // We can't safely \"move\" the key to a different name in the output\n        // object (because there may already be something there), so we issue a\n        // \"required key\" error if the key validation changes the key\n        return ctx.issueRequiredKey(input, key)\n      }\n\n      const valueResult = ctx.validateChild(input, key, this.valueSchema)\n      if (!valueResult.success) return valueResult\n\n      if (!Object.is(valueResult.value, input[key])) {\n        if (ctx.options.mode === 'validate') {\n          // In \"validate\" mode, we can't modify the input, so we issue an error\n          return ctx.issueInvalidPropertyValue(input, key, [valueResult.value])\n        }\n\n        copy ??= { ...input }\n        copy[key] = valueResult.value\n      }\n    }\n\n    return ctx.success(copy ?? input)\n  }\n}\n\n/**\n * Creates a dictionary schema for validating map-like objects.\n *\n * Validates objects where all keys match the key schema and all values\n * match the value schema. Useful for dynamic key-value mappings.\n *\n * @param key - Schema to validate each key (must be a string validator)\n * @param value - Schema to validate each value\n * @returns A new {@link DictSchema} instance\n *\n * @example\n * ```ts\n * // String to number mapping\n * const scoresSchema = l.dict(l.string(), l.integer())\n * scoresSchema.parse({ alice: 100, bob: 85 })\n *\n * // Constrained keys\n * const langSchema = l.dict(\n *   l.string({ minLength: 2, maxLength: 5 }), // Language codes\n *   l.string() // Translations\n * )\n *\n * // Complex values\n * const usersById = l.dict(\n *   l.string({ format: 'did' }),\n *   l.object({ name: l.string(), age: l.integer() })\n * )\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function dict<\n  const TKey extends Validator<string>,\n  const TValue extends Validator,\n>(key: TKey, value: TValue) {\n  return new DictSchema<TKey, TValue>(key, value)\n}\n"]}

package/dist/schema/discriminated-union.js

@@ -1,11 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DiscriminatedUnionSchema = void 0;
-exports.discriminatedUnion = discriminatedUnion;
-const lex_data_1 = require("@atproto/lex-data");
-const core_js_1 = require("../core.js");
-const enum_js_1 = require("./enum.js");
-const literal_js_1 = require("./literal.js");
+import { isPlainObject } from '@atproto/lex-data';
+import { Schema, } from '../core.js';
+import { EnumSchema } from './enum.js';
+import { LiteralSchema } from './literal.js';
 /**
  * Schema for validating discriminated unions of objects.
  *
@@ -28,22 +24,19 @@ const literal_js_1 = require("./literal.js");
  * ])
  * ```
  */
-class DiscriminatedUnionSchema extends core_js_1.Schema {
-    discriminator;
-    variants;
-    type = 'discriminatedUnion';
-    variantsMap;
+export class DiscriminatedUnionSchema extends Schema {
     constructor(discriminator, variants) {
         super();
         this.discriminator = discriminator;
         this.variants = variants;
+        this.type = 'discriminatedUnion';
         // Although we usually try to avoid initialization work in constructors,
         // here it is necessary to ensure that invalid discriminated throw from the
         // place of construction, rather than later during validation.
         this.variantsMap = buildVariantsMap(discriminator, variants);
     }
     validateInContext(input, ctx) {
-        if (!(0, lex_data_1.isPlainObject)(input)) {
+        if (!isPlainObject(input)) {
             return ctx.issueUnexpectedType(input, 'object');
         }
         const { discriminator } = this;
@@ -60,18 +53,17 @@ class DiscriminatedUnionSchema extends core_js_1.Schema {
         ]);
     }
 }
-exports.DiscriminatedUnionSchema = DiscriminatedUnionSchema;
 function buildVariantsMap(discriminator, variants) {
     const variantsMap = new Map();
     for (const variant of variants) {
         const schema = variant.shape[discriminator];
-        if (schema instanceof literal_js_1.LiteralSchema) {
+        if (schema instanceof LiteralSchema) {
             if (variantsMap.has(schema.value)) {
                 throw new TypeError(`Overlapping discriminator value: ${schema.value}`);
             }
             variantsMap.set(schema.value, variant);
         }
-        else if (schema instanceof enum_js_1.EnumSchema) {
+        else if (schema instanceof EnumSchema) {
             for (const val of schema.values) {
                 if (variantsMap.has(val)) {
                     throw new TypeError(`Overlapping discriminator value: ${val}`);
@@ -116,7 +108,7 @@ function buildVariantsMap(discriminator, variants) {
  * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
-function discriminatedUnion(discriminator, variants) {
+export function discriminatedUnion(discriminator, variants) {
     return new DiscriminatedUnionSchema(discriminator, variants);
 }
 //# sourceMappingURL=discriminated-union.js.map

package/dist/schema/discriminated-union.js.map

@@ -1 +1 @@
-{"version":3,"file":"discriminated-union.js","sourceRoot":"","sources":["../../src/schema/discriminated-union.ts"],"names":[],"mappings":"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","sourcesContent":["import { isPlainObject } from '@atproto/lex-data'\nimport {\n  InferInput,\n  InferOutput,\n  Schema,\n  ValidationContext,\n  ValidationResult,\n  Validator,\n} from '../core.js'\nimport { EnumSchema } from './enum.js'\nimport { LiteralSchema } from './literal.js'\nimport { ObjectSchema } from './object.js'\n\n/**\n * Type representing a single variant in a discriminated union.\n *\n * Must be an ObjectSchema with the discriminator property using either\n * a LiteralSchema or EnumSchema.\n *\n * @template Discriminator - The discriminator property name\n */\nexport type DiscriminatedUnionVariant<Discriminator extends string = string> =\n  ObjectSchema<Record<Discriminator, EnumSchema<any> | LiteralSchema<any>>>\n\n/**\n * Type representing a non-empty tuple of discriminated union variants.\n *\n * @template TDiscriminator - The discriminator property name\n */\nexport type DiscriminatedUnionVariants<TDiscriminator extends string> =\n  readonly [\n    DiscriminatedUnionVariant<TDiscriminator>,\n    ...DiscriminatedUnionVariant<TDiscriminator>[],\n  ]\n\ntype DiscriminatedUnionSchemaInput<TVariants extends readonly Validator[]> =\n  TVariants extends readonly [\n    infer TValidator extends Validator,\n    ...infer TRest extends readonly Validator[],\n  ]\n    ? InferInput<TValidator> | DiscriminatedUnionSchemaInput<TRest>\n    : never\n\ntype DiscriminatedUnionSchemaOutput<TVariants extends readonly Validator[]> =\n  TVariants extends readonly [\n    infer TValidator extends Validator,\n    ...infer TRest extends readonly Validator[],\n  ]\n    ? InferOutput<TValidator> | DiscriminatedUnionSchemaOutput<TRest>\n    : never\n\n/**\n * Schema for validating discriminated unions of objects.\n *\n * More efficient than regular union schemas when discriminating on a known\n * property. Looks up the correct variant schema directly based on the\n * discriminator value instead of trying each variant in sequence.\n *\n * @note There is no discriminated union in Lexicon schemas. This is a custom\n * extension to allow optimized validation of union of objects when using the\n * lex library programmatically (i.e. not code generated from a lexicon schema).\n *\n * @template TDiscriminator - The discriminator property name\n * @template TVariants - Tuple type of the variant schemas\n *\n * @example\n * ```ts\n * const schema = new DiscriminatedUnionSchema('type', [\n *   l.object({ type: l.literal('text'), content: l.string() }),\n *   l.object({ type: l.literal('image'), url: l.string() }),\n * ])\n * ```\n */\nexport class DiscriminatedUnionSchema<\n  const TDiscriminator extends string,\n  const TVariants extends DiscriminatedUnionVariants<TDiscriminator>,\n> extends Schema<\n  DiscriminatedUnionSchemaInput<TVariants>,\n  DiscriminatedUnionSchemaOutput<TVariants>\n> {\n  readonly type = 'discriminatedUnion' as const\n\n  readonly variantsMap: Map<unknown, DiscriminatedUnionVariant<TDiscriminator>>\n\n  constructor(\n    readonly discriminator: TDiscriminator,\n    readonly variants: TVariants,\n  ) {\n    super()\n\n    // Although we usually try to avoid initialization work in constructors,\n    // here it is necessary to ensure that invalid discriminated throw from the\n    // place of construction, rather than later during validation.\n    this.variantsMap = buildVariantsMap(discriminator, variants)\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (!isPlainObject(input)) {\n      return ctx.issueUnexpectedType(input, 'object')\n    }\n\n    const { discriminator } = this\n\n    if (!Object.hasOwn(input, discriminator)) {\n      return ctx.issueRequiredKey(input, discriminator)\n    }\n\n    const discriminatorValue = input[discriminator]\n\n    const variant = this.variantsMap.get(discriminatorValue)\n    if (variant) {\n      return ctx.validate(input, variant) as ValidationResult<\n        DiscriminatedUnionSchemaInput<TVariants>\n      >\n    }\n\n    return ctx.issueInvalidPropertyValue(input, discriminator, [\n      ...this.variantsMap.keys(),\n    ])\n  }\n}\n\nfunction buildVariantsMap<Discriminator extends string>(\n  discriminator: Discriminator,\n  variants: DiscriminatedUnionVariants<Discriminator>,\n) {\n  const variantsMap = new Map<\n    unknown,\n    DiscriminatedUnionVariant<Discriminator>\n  >()\n\n  for (const variant of variants) {\n    const schema = variant.shape[discriminator]\n    if (schema instanceof LiteralSchema) {\n      if (variantsMap.has(schema.value)) {\n        throw new TypeError(`Overlapping discriminator value: ${schema.value}`)\n      }\n      variantsMap.set(schema.value, variant)\n    } else if (schema instanceof EnumSchema) {\n      for (const val of schema.values) {\n        if (variantsMap.has(val)) {\n          throw new TypeError(`Overlapping discriminator value: ${val}`)\n        }\n        variantsMap.set(val, variant)\n      }\n    } else {\n      // Only enumerable discriminator schemas are supported\n\n      // Should never happen if types are used correctly\n      throw new TypeError(\n        `Discriminator schema must be a LiteralSchema or EnumSchema`,\n      )\n    }\n  }\n\n  return variantsMap\n}\n\n/**\n * Creates a discriminated union schema for efficient object type switching.\n *\n * Unlike regular `union()`, this schema uses a discriminator property to\n * directly look up the correct variant, providing O(1) validation instead\n * of trying each variant sequentially.\n *\n * @param discriminator - Property name to discriminate on\n * @param variants - Non-empty array of object schemas with the discriminator property\n * @returns A new {@link DiscriminatedUnionSchema} instance\n *\n * @example\n * ```ts\n * // Message types discriminated by 'kind'\n * const messageSchema = l.discriminatedUnion('kind', [\n *   l.object({ kind: l.literal('text'), text: l.string() }),\n *   l.object({ kind: l.literal('image'), url: l.string(), alt: l.optional(l.string()) }),\n *   l.object({ kind: l.literal('video'), url: l.string(), duration: l.integer() }),\n * ])\n *\n * // Using enums for multiple values mapping to same variant\n * const statusSchema = l.discriminatedUnion('status', [\n *   l.object({ status: l.enum(['pending', 'processing']), startedAt: l.string() }),\n *   l.object({ status: l.literal('completed'), completedAt: l.string() }),\n *   l.object({ status: l.literal('failed'), error: l.string() }),\n * ])\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function discriminatedUnion<\n  const Discriminator extends string,\n  const Options extends DiscriminatedUnionVariants<Discriminator>,\n>(discriminator: Discriminator, variants: Options) {\n  return new DiscriminatedUnionSchema<Discriminator, Options>(\n    discriminator,\n    variants,\n  )\n}\n"]}
+{"version":3,"file":"discriminated-union.js","sourceRoot":"","sources":["../../src/schema/discriminated-union.ts"],"names":[],"mappings":"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","sourcesContent":["import { isPlainObject } from '@atproto/lex-data'\nimport {\n  InferInput,\n  InferOutput,\n  Schema,\n  ValidationContext,\n  ValidationResult,\n  Validator,\n} from '../core.js'\nimport { EnumSchema } from './enum.js'\nimport { LiteralSchema } from './literal.js'\nimport { ObjectSchema } from './object.js'\n\n/**\n * Type representing a single variant in a discriminated union.\n *\n * Must be an ObjectSchema with the discriminator property using either\n * a LiteralSchema or EnumSchema.\n *\n * @template Discriminator - The discriminator property name\n */\nexport type DiscriminatedUnionVariant<Discriminator extends string = string> =\n  ObjectSchema<Record<Discriminator, EnumSchema<any> | LiteralSchema<any>>>\n\n/**\n * Type representing a non-empty tuple of discriminated union variants.\n *\n * @template TDiscriminator - The discriminator property name\n */\nexport type DiscriminatedUnionVariants<TDiscriminator extends string> =\n  readonly [\n    DiscriminatedUnionVariant<TDiscriminator>,\n    ...DiscriminatedUnionVariant<TDiscriminator>[],\n  ]\n\ntype DiscriminatedUnionSchemaInput<TVariants extends readonly Validator[]> =\n  TVariants extends readonly [\n    infer TValidator extends Validator,\n    ...infer TRest extends readonly Validator[],\n  ]\n    ? InferInput<TValidator> | DiscriminatedUnionSchemaInput<TRest>\n    : never\n\ntype DiscriminatedUnionSchemaOutput<TVariants extends readonly Validator[]> =\n  TVariants extends readonly [\n    infer TValidator extends Validator,\n    ...infer TRest extends readonly Validator[],\n  ]\n    ? InferOutput<TValidator> | DiscriminatedUnionSchemaOutput<TRest>\n    : never\n\n/**\n * Schema for validating discriminated unions of objects.\n *\n * More efficient than regular union schemas when discriminating on a known\n * property. Looks up the correct variant schema directly based on the\n * discriminator value instead of trying each variant in sequence.\n *\n * @note There is no discriminated union in Lexicon schemas. This is a custom\n * extension to allow optimized validation of union of objects when using the\n * lex library programmatically (i.e. not code generated from a lexicon schema).\n *\n * @template TDiscriminator - The discriminator property name\n * @template TVariants - Tuple type of the variant schemas\n *\n * @example\n * ```ts\n * const schema = new DiscriminatedUnionSchema('type', [\n *   l.object({ type: l.literal('text'), content: l.string() }),\n *   l.object({ type: l.literal('image'), url: l.string() }),\n * ])\n * ```\n */\nexport class DiscriminatedUnionSchema<\n  const TDiscriminator extends string,\n  const TVariants extends DiscriminatedUnionVariants<TDiscriminator>,\n> extends Schema<\n  DiscriminatedUnionSchemaInput<TVariants>,\n  DiscriminatedUnionSchemaOutput<TVariants>\n> {\n  readonly type = 'discriminatedUnion' as const\n\n  readonly variantsMap: Map<unknown, DiscriminatedUnionVariant<TDiscriminator>>\n\n  constructor(\n    readonly discriminator: TDiscriminator,\n    readonly variants: TVariants,\n  ) {\n    super()\n\n    // Although we usually try to avoid initialization work in constructors,\n    // here it is necessary to ensure that invalid discriminated throw from the\n    // place of construction, rather than later during validation.\n    this.variantsMap = buildVariantsMap(discriminator, variants)\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (!isPlainObject(input)) {\n      return ctx.issueUnexpectedType(input, 'object')\n    }\n\n    const { discriminator } = this\n\n    if (!Object.hasOwn(input, discriminator)) {\n      return ctx.issueRequiredKey(input, discriminator)\n    }\n\n    const discriminatorValue = input[discriminator]\n\n    const variant = this.variantsMap.get(discriminatorValue)\n    if (variant) {\n      return ctx.validate(input, variant) as ValidationResult<\n        DiscriminatedUnionSchemaInput<TVariants>\n      >\n    }\n\n    return ctx.issueInvalidPropertyValue(input, discriminator, [\n      ...this.variantsMap.keys(),\n    ])\n  }\n}\n\nfunction buildVariantsMap<Discriminator extends string>(\n  discriminator: Discriminator,\n  variants: DiscriminatedUnionVariants<Discriminator>,\n) {\n  const variantsMap = new Map<\n    unknown,\n    DiscriminatedUnionVariant<Discriminator>\n  >()\n\n  for (const variant of variants) {\n    const schema = variant.shape[discriminator]\n    if (schema instanceof LiteralSchema) {\n      if (variantsMap.has(schema.value)) {\n        throw new TypeError(`Overlapping discriminator value: ${schema.value}`)\n      }\n      variantsMap.set(schema.value, variant)\n    } else if (schema instanceof EnumSchema) {\n      for (const val of schema.values) {\n        if (variantsMap.has(val)) {\n          throw new TypeError(`Overlapping discriminator value: ${val}`)\n        }\n        variantsMap.set(val, variant)\n      }\n    } else {\n      // Only enumerable discriminator schemas are supported\n\n      // Should never happen if types are used correctly\n      throw new TypeError(\n        `Discriminator schema must be a LiteralSchema or EnumSchema`,\n      )\n    }\n  }\n\n  return variantsMap\n}\n\n/**\n * Creates a discriminated union schema for efficient object type switching.\n *\n * Unlike regular `union()`, this schema uses a discriminator property to\n * directly look up the correct variant, providing O(1) validation instead\n * of trying each variant sequentially.\n *\n * @param discriminator - Property name to discriminate on\n * @param variants - Non-empty array of object schemas with the discriminator property\n * @returns A new {@link DiscriminatedUnionSchema} instance\n *\n * @example\n * ```ts\n * // Message types discriminated by 'kind'\n * const messageSchema = l.discriminatedUnion('kind', [\n *   l.object({ kind: l.literal('text'), text: l.string() }),\n *   l.object({ kind: l.literal('image'), url: l.string(), alt: l.optional(l.string()) }),\n *   l.object({ kind: l.literal('video'), url: l.string(), duration: l.integer() }),\n * ])\n *\n * // Using enums for multiple values mapping to same variant\n * const statusSchema = l.discriminatedUnion('status', [\n *   l.object({ status: l.enum(['pending', 'processing']), startedAt: l.string() }),\n *   l.object({ status: l.literal('completed'), completedAt: l.string() }),\n *   l.object({ status: l.literal('failed'), error: l.string() }),\n * ])\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function discriminatedUnion<\n  const Discriminator extends string,\n  const Options extends DiscriminatedUnionVariants<Discriminator>,\n>(discriminator: Discriminator, variants: Options) {\n  return new DiscriminatedUnionSchema<Discriminator, Options>(\n    discriminator,\n    variants,\n  )\n}\n"]}

package/dist/schema/enum.js

@@ -1,9 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EnumSchema = void 0;
-exports.enumSchema = enumSchema;
-exports.enum = enumSchema;
-const core_js_1 = require("../core.js");
+import { Schema } from '../core.js';
 /**
  * Schema that accepts one of several specific literal values.
  *
@@ -19,12 +14,11 @@ const core_js_1 = require("../core.js");
  * schema.validate('invalid') // fails
  * ```
  */
-class EnumSchema extends core_js_1.Schema {
-    values;
-    type = 'enum';
+export class EnumSchema extends Schema {
     constructor(values) {
         super();
         this.values = values;
+        this.type = 'enum';
     }
     validateInContext(input, ctx) {
         if (!this.values.includes(input)) {
@@ -33,7 +27,6 @@ class EnumSchema extends core_js_1.Schema {
         return ctx.success(input);
     }
 }
-exports.EnumSchema = EnumSchema;
 /**
  * Creates an enum schema that accepts one of the specified values.
  *
@@ -68,7 +61,9 @@ exports.EnumSchema = EnumSchema;
  * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
-function enumSchema(value) {
+export function enumSchema(value) {
     return new EnumSchema(value);
 }
+// @NOTE "enum" is a reserved keyword in JS/TS
+export { enumSchema as enum };
 //# sourceMappingURL=enum.js.map

package/dist/schema/enum.js.map

@@ -1 +1 @@
-{"version":3,"file":"enum.js","sourceRoot":"","sources":["../../src/schema/enum.ts"],"names":[],"mappings":";;;AAqEA,gCAIC;AAGsB,0BAAI;AA5E3B,wCAAsD;AAEtD;;;;;;;;;;;;;;GAcG;AACH,MAAa,UAEX,SAAQ,gBAAc;IAGD;IAFZ,IAAI,GAAG,MAAe,CAAA;IAE/B,YAAqB,MAAyB;QAC5C,KAAK,EAAE,CAAA;QADY,WAAM,GAAN,MAAM,CAAmB;IAE9C,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,CAAE,IAAI,CAAC,MAA6B,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;YACzD,OAAO,GAAG,CAAC,iBAAiB,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,CAAA;QAClD,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,KAAe,CAAC,CAAA;IACrC,CAAC;CACF;AAhBD,gCAgBC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAwB;AACxB,SAAgB,UAAU,CACxB,KAAmB;IAEnB,OAAO,IAAI,UAAU,CAAI,KAAK,CAAC,CAAA;AACjC,CAAC","sourcesContent":["import { Schema, ValidationContext } from '../core.js'\n\n/**\n * Schema that accepts one of several specific literal values.\n *\n * Validates that the input matches one of the allowed values using strict\n * equality. Similar to TypeScript union of literals.\n *\n * @template TValue - The union of literal types\n *\n * @example\n * ```ts\n * const schema = new EnumSchema(['pending', 'active', 'completed'])\n * schema.validate('active')  // success\n * schema.validate('invalid') // fails\n * ```\n */\nexport class EnumSchema<\n  const TValue extends null | string | number | boolean,\n> extends Schema<TValue> {\n  readonly type = 'enum' as const\n\n  constructor(readonly values: readonly TValue[]) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (!(this.values as readonly unknown[]).includes(input)) {\n      return ctx.issueInvalidValue(input, this.values)\n    }\n\n    return ctx.success(input as TValue)\n  }\n}\n\n/**\n * Creates an enum schema that accepts one of the specified values.\n *\n * Similar to TypeScript's union of string literals. Use `l.enum()` for\n * the namespace-friendly alias.\n *\n * @param value - Array of allowed values\n * @returns A new {@link EnumSchema} instance\n *\n * @example\n * ```ts\n * // String enum\n * const statusSchema = l.enum(['pending', 'active', 'completed', 'failed'])\n *\n * // Number enum\n * const prioritySchema = l.enum([1, 2, 3, 4, 5])\n *\n * // Mixed types\n * const mixedSchema = l.enum(['auto', 0, 1, true])\n *\n * // Use in objects\n * const taskSchema = l.object({\n *   title: l.string(),\n *   status: l.enum(['todo', 'in-progress', 'done']),\n * })\n *\n * // In discriminated unions\n * const resultSchema = l.discriminatedUnion('status', [\n *   l.object({ status: l.enum(['pending', 'processing']), progress: l.integer() }),\n *   l.object({ status: l.literal('completed'), result: l.unknown() }),\n * ])\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function enumSchema<const V extends null | string | number | boolean>(\n  value: readonly V[],\n) {\n  return new EnumSchema<V>(value)\n}\n\n// @NOTE \"enum\" is a reserved keyword in JS/TS\nexport { enumSchema as enum }\n"]}
+{"version":3,"file":"enum.js","sourceRoot":"","sources":["../../src/schema/enum.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAqB,MAAM,YAAY,CAAA;AAEtD;;;;;;;;;;;;;;GAcG;AACH,MAAM,OAAO,UAEX,SAAQ,MAAc;IAGtB,YAAqB,MAAyB;QAC5C,KAAK,EAAE,CAAA;QADY,WAAM,GAAN,MAAM,CAAmB;QAFrC,SAAI,GAAG,MAAe,CAAA;IAI/B,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,CAAE,IAAI,CAAC,MAA6B,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;YACzD,OAAO,GAAG,CAAC,iBAAiB,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,CAAA;QAClD,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,KAAe,CAAC,CAAA;IACrC,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAwB;AACxB,MAAM,UAAU,UAAU,CACxB,KAAmB;IAEnB,OAAO,IAAI,UAAU,CAAI,KAAK,CAAC,CAAA;AACjC,CAAC;AAED,8CAA8C;AAC9C,OAAO,EAAE,UAAU,IAAI,IAAI,EAAE,CAAA","sourcesContent":["import { Schema, ValidationContext } from '../core.js'\n\n/**\n * Schema that accepts one of several specific literal values.\n *\n * Validates that the input matches one of the allowed values using strict\n * equality. Similar to TypeScript union of literals.\n *\n * @template TValue - The union of literal types\n *\n * @example\n * ```ts\n * const schema = new EnumSchema(['pending', 'active', 'completed'])\n * schema.validate('active')  // success\n * schema.validate('invalid') // fails\n * ```\n */\nexport class EnumSchema<\n  const TValue extends null | string | number | boolean,\n> extends Schema<TValue> {\n  readonly type = 'enum' as const\n\n  constructor(readonly values: readonly TValue[]) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (!(this.values as readonly unknown[]).includes(input)) {\n      return ctx.issueInvalidValue(input, this.values)\n    }\n\n    return ctx.success(input as TValue)\n  }\n}\n\n/**\n * Creates an enum schema that accepts one of the specified values.\n *\n * Similar to TypeScript's union of string literals. Use `l.enum()` for\n * the namespace-friendly alias.\n *\n * @param value - Array of allowed values\n * @returns A new {@link EnumSchema} instance\n *\n * @example\n * ```ts\n * // String enum\n * const statusSchema = l.enum(['pending', 'active', 'completed', 'failed'])\n *\n * // Number enum\n * const prioritySchema = l.enum([1, 2, 3, 4, 5])\n *\n * // Mixed types\n * const mixedSchema = l.enum(['auto', 0, 1, true])\n *\n * // Use in objects\n * const taskSchema = l.object({\n *   title: l.string(),\n *   status: l.enum(['todo', 'in-progress', 'done']),\n * })\n *\n * // In discriminated unions\n * const resultSchema = l.discriminatedUnion('status', [\n *   l.object({ status: l.enum(['pending', 'processing']), progress: l.integer() }),\n *   l.object({ status: l.literal('completed'), result: l.unknown() }),\n * ])\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function enumSchema<const V extends null | string | number | boolean>(\n  value: readonly V[],\n) {\n  return new EnumSchema<V>(value)\n}\n\n// @NOTE \"enum\" is a reserved keyword in JS/TS\nexport { enumSchema as enum }\n"]}

package/dist/schema/integer.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.integer = exports.IntegerSchema = void 0;
-const core_js_1 = require("../core.js");
-const memoize_js_1 = require("../util/memoize.js");
+import { Schema } from '../core.js';
+import { memoizedOptions } from '../util/memoize.js';
 /**
  * Schema for validating integer values with optional range constraints.
  *
@@ -15,12 +12,11 @@ const memoize_js_1 = require("../util/memoize.js");
  * const result = schema.validate(42)
  * ```
  */
-class IntegerSchema extends core_js_1.Schema {
-    options;
-    type = 'integer';
+export class IntegerSchema extends Schema {
     constructor(options) {
         super();
         this.options = options;
+        this.type = 'integer';
     }
     validateInContext(input, ctx) {
         if (!isInteger(input)) {
@@ -35,7 +31,6 @@ class IntegerSchema extends core_js_1.Schema {
         return ctx.success(input);
     }
 }
-exports.IntegerSchema = IntegerSchema;
 /**
  * Simple wrapper around {@link Number.isSafeInteger} that acts as a type guard.
  */
@@ -66,7 +61,7 @@ function isInteger(input) {
  * const ageSchema = l.integer({ minimum: 0, maximum: 150 })
  * ```
  */
-exports.integer = (0, memoize_js_1.memoizedOptions)(function (options) {
+export const integer = /*#__PURE__*/ memoizedOptions(function (options) {
     return new IntegerSchema(options);
 });
 //# sourceMappingURL=integer.js.map