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

package/dist/core/string-format.js

@@ -1,15 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.STRING_FORMATS = exports.isUriString = exports.isTidString = exports.isRecordKeyString = exports.isNsidString = exports.isLanguageString = exports.isHandleString = exports.isDidString = exports.isCidString = exports.isAtUriString = exports.ifAtUriString = exports.assertAtUriString = exports.asAtUriString = exports.toDatetimeString = exports.currentDatetimeString = exports.isDatetimeString = exports.ifDatetimeString = exports.assertDatetimeString = exports.asDatetimeString = exports.isHandleIdentifier = exports.isDidIdentifier = exports.isAtIdentifierString = exports.ifAtIdentifierString = exports.assertAtIdentifierString = exports.asAtIdentifierString = void 0;
-exports.isDatetimeStringLenient = isDatetimeStringLenient;
-exports.isAtUriStringLenient = isAtUriStringLenient;
-exports.isStringFormat = isStringFormat;
-exports.assertStringFormat = assertStringFormat;
-exports.asStringFormat = asStringFormat;
-exports.ifStringFormat = ifStringFormat;
-const iso_datestring_validator_1 = require("iso-datestring-validator");
-const lex_data_1 = require("@atproto/lex-data");
-const syntax_1 = require("@atproto/syntax");
+import isoDatestringValidator from 'iso-datestring-validator';
+const { isValidISODateString } = isoDatestringValidator;
+import { validateCidString } from '@atproto/lex-data';
+import { isAtIdentifierString, isAtUriString, isDatetimeString, isValidDid, isValidHandle, isValidLanguage, isValidNsid, isValidRecordKey, isValidTid, isValidUri, } from '@atproto/syntax';
 // -----------------------------------------------------------------------------
 // Individual string format types and type guards
 // -----------------------------------------------------------------------------
@@ -17,33 +9,23 @@ const syntax_1 = require("@atproto/syntax");
 // documentation for types and utilities that are already well-defined there.
 // @TODO rework other string formats in @atproto/syntax to follow this pattern
 // and re-export here, e.g. language tags, NSIDs, record keys, etc.
-var syntax_2 = require("@atproto/syntax");
-Object.defineProperty(exports, "asAtIdentifierString", { enumerable: true, get: function () { return syntax_2.asAtIdentifierString; } });
-Object.defineProperty(exports, "assertAtIdentifierString", { enumerable: true, get: function () { return syntax_2.assertAtIdentifierString; } });
-Object.defineProperty(exports, "ifAtIdentifierString", { enumerable: true, get: function () { return syntax_2.ifAtIdentifierString; } });
-Object.defineProperty(exports, "isAtIdentifierString", { enumerable: true, get: function () { return syntax_2.isAtIdentifierString; } });
+export { asAtIdentifierString, assertAtIdentifierString, ifAtIdentifierString, isAtIdentifierString, } from '@atproto/syntax';
 // AtIdentifierString utilities
-var syntax_3 = require("@atproto/syntax");
-Object.defineProperty(exports, "isDidIdentifier", { enumerable: true, get: function () { return syntax_3.isDidIdentifier; } });
-Object.defineProperty(exports, "isHandleIdentifier", { enumerable: true, get: function () { return syntax_3.isHandleIdentifier; } });
-var syntax_4 = require("@atproto/syntax");
-Object.defineProperty(exports, "asDatetimeString", { enumerable: true, get: function () { return syntax_4.asDatetimeString; } });
-Object.defineProperty(exports, "assertDatetimeString", { enumerable: true, get: function () { return syntax_4.assertDatetimeString; } });
-Object.defineProperty(exports, "ifDatetimeString", { enumerable: true, get: function () { return syntax_4.ifDatetimeString; } });
-Object.defineProperty(exports, "isDatetimeString", { enumerable: true, get: function () { return syntax_4.isDatetimeString; } });
+export { isDidIdentifier, isHandleIdentifier } from '@atproto/syntax';
+export { asDatetimeString, assertDatetimeString, ifDatetimeString, isDatetimeString, } from '@atproto/syntax';
 /**
  * Matches any ISO-ish datetime string. This is a more lenient check than
  * the strict {@link isDatetimeString} guard, which only allows datetimes that
  * fully conform to the AT Protocol specification (e.g. must include timezone).
  */
-function isDatetimeStringLenient(input) {
+export function isDatetimeStringLenient(input) {
     // @NOTE the returned type assertion is inaccurate wrt. the DatetimeString
     // type definition. A more accurate solution would be to use a branded type
     // instead of a template literal for the "datetime" format
     if (typeof input !== 'string')
         return false;
     try {
-        return (0, iso_datestring_validator_1.isValidISODateString)(input);
+        return isValidISODateString(input);
     }
     catch {
         // @NOTE isValidISODateString throws on some inputs
@@ -51,22 +33,16 @@ function isDatetimeStringLenient(input) {
     }
 }
 // DatetimeString utilities
-var syntax_5 = require("@atproto/syntax");
-Object.defineProperty(exports, "currentDatetimeString", { enumerable: true, get: function () { return syntax_5.currentDatetimeString; } });
-Object.defineProperty(exports, "toDatetimeString", { enumerable: true, get: function () { return syntax_5.toDatetimeString; } });
-var syntax_6 = require("@atproto/syntax");
-Object.defineProperty(exports, "asAtUriString", { enumerable: true, get: function () { return syntax_6.asAtUriString; } });
-Object.defineProperty(exports, "assertAtUriString", { enumerable: true, get: function () { return syntax_6.assertAtUriString; } });
-Object.defineProperty(exports, "ifAtUriString", { enumerable: true, get: function () { return syntax_6.ifAtUriString; } });
-Object.defineProperty(exports, "isAtUriString", { enumerable: true, get: function () { return syntax_6.isAtUriString; } });
+export { currentDatetimeString, toDatetimeString } from '@atproto/syntax';
+export { asAtUriString, assertAtUriString, ifAtUriString, isAtUriString, } from '@atproto/syntax';
 /**
  * Lenient version of {@link isAtUriString} that does not enforce the validity
  * of the record key (rkey) path component (if present).
  *
  * @see {@link isAtUriString}
  */
-function isAtUriStringLenient(input) {
-    return (0, syntax_1.isAtUriString)(input, { strict: false });
+export function isAtUriStringLenient(input) {
+    return isAtUriString(input, { strict: false });
 }
 /**
  * Type guard that checks if a value is a valid CID string.
@@ -74,69 +50,69 @@ function isAtUriStringLenient(input) {
  * @param value - The value to check
  * @returns `true` if the value is a valid CID string
  */
-exports.isCidString = ((v) => (0, lex_data_1.validateCidString)(v));
+export const isCidString = ((v) => validateCidString(v));
 /**
  * Type guard that checks if a value is a valid DID string.
  *
  * @param value - The value to check
  * @returns `true` if the value is a valid DID string
  */
-exports.isDidString = syntax_1.isValidDid;
+export const isDidString = isValidDid;
 /**
  * Type guard that checks if a value is a valid handle string.
  *
  * @param value - The value to check
  * @returns `true` if the value is a valid handle string
  */
-exports.isHandleString = syntax_1.isValidHandle;
+export const isHandleString = isValidHandle;
 /**
  * Type guard that checks if a value is a valid BCP-47 language tag.
  *
  * @param value - The value to check
  * @returns `true` if the value is a valid language string
  */
-exports.isLanguageString = syntax_1.isValidLanguage;
+export const isLanguageString = isValidLanguage;
 /**
  * Type guard that checks if a value is a valid NSID string.
  *
  * @param value - The value to check
  * @returns `true` if the value is a valid NSID string
  */
-exports.isNsidString = syntax_1.isValidNsid;
+export const isNsidString = isValidNsid;
 /**
  * Type guard that checks if a value is a valid record key string.
  *
  * @param value - The value to check
  * @returns `true` if the value is a valid record key string
  */
-exports.isRecordKeyString = syntax_1.isValidRecordKey;
+export const isRecordKeyString = isValidRecordKey;
 /**
  * Type guard that checks if a value is a valid TID string.
  *
  * @param value - The value to check
  * @returns `true` if the value is a valid TID string
  */
-exports.isTidString = syntax_1.isValidTid;
+export const isTidString = isValidTid;
 /**
  * Type guard that checks if a value is a valid URI string.
  *
  * @param value - The value to check
  * @returns `true` if the value is a valid URI string
  */
-exports.isUriString = syntax_1.isValidUri;
+export const isUriString = isValidUri;
 const stringFormatVerifiers = /*#__PURE__*/ Object.freeze({
     __proto__: null,
-    'at-identifier': [syntax_1.isAtIdentifierString],
-    'at-uri': [syntax_1.isAtUriString, isAtUriStringLenient],
-    cid: [exports.isCidString],
-    datetime: [syntax_1.isDatetimeString, isDatetimeStringLenient],
-    did: [exports.isDidString],
-    handle: [exports.isHandleString],
-    language: [exports.isLanguageString],
-    nsid: [exports.isNsidString],
-    'record-key': [exports.isRecordKeyString],
-    tid: [exports.isTidString],
-    uri: [exports.isUriString],
+    'at-identifier': [isAtIdentifierString],
+    'at-uri': [isAtUriString, isAtUriStringLenient],
+    cid: [isCidString],
+    datetime: [isDatetimeString, isDatetimeStringLenient],
+    did: [isDidString],
+    handle: [isHandleString],
+    language: [isLanguageString],
+    nsid: [isNsidString],
+    'record-key': [isRecordKeyString],
+    tid: [isTidString],
+    uri: [isUriString],
 });
 /**
  * Type guard that checks if a string matches a specific format.
@@ -157,7 +133,7 @@ const stringFormatVerifiers = /*#__PURE__*/ Object.freeze({
  * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
-function isStringFormat(input, format, options) {
+export function isStringFormat(input, format, options) {
     const formatVerifier = stringFormatVerifiers[format];
     // Fool-proof
     if (!formatVerifier)
@@ -183,7 +159,7 @@ function isStringFormat(input, format, options) {
  * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
-function assertStringFormat(input, format, options) {
+export function assertStringFormat(input, format, options) {
     if (!isStringFormat(input, format, options)) {
         throw new TypeError(`Invalid string format (${format}): ${input}`);
     }
@@ -207,7 +183,7 @@ function assertStringFormat(input, format, options) {
  * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
-function asStringFormat(input, format, options) {
+export function asStringFormat(input, format, options) {
     assertStringFormat(input, format, options);
     return input;
 }
@@ -232,7 +208,7 @@ function asStringFormat(input, format, options) {
  * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
-function ifStringFormat(input, format, options) {
+export function ifStringFormat(input, format, options) {
     return isStringFormat(input, format, options) ? input : undefined;
 }
 /**
@@ -245,6 +221,6 @@ function ifStringFormat(input, format, options) {
  * }
  * ```
  */
-exports.STRING_FORMATS = Object.freeze(
+export const STRING_FORMATS = /*#__PURE__*/ Object.freeze(
 /*#__PURE__*/ Object.keys(stringFormatVerifiers));
 //# sourceMappingURL=string-format.js.map

package/dist/core/string-format.js.map

@@ -1 +1 @@
-{"version":3,"file":"string-format.js","sourceRoot":"","sources":["../../src/core/string-format.ts"],"names":[],"mappings":"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","sourcesContent":["import { isValidISODateString } from 'iso-datestring-validator'\nimport { validateCidString } from '@atproto/lex-data'\nimport {\n  AtIdentifierString,\n  AtUriString,\n  DatetimeString,\n  DidString,\n  HandleString,\n  NsidString,\n  RecordKeyString,\n  TidString,\n  UriString,\n  isAtIdentifierString,\n  isAtUriString,\n  isDatetimeString,\n  isValidDid,\n  isValidHandle,\n  isValidLanguage,\n  isValidNsid,\n  isValidRecordKey,\n  isValidTid,\n  isValidUri,\n} from '@atproto/syntax'\nimport { CheckFn } from '../util/assertion-util.js'\n\n// -----------------------------------------------------------------------------\n// Individual string format types and type guards\n// -----------------------------------------------------------------------------\n\n// Re-exporting from @atproto/syntax without modification to preserve types and\n// documentation for types and utilities that are already well-defined there.\n// @TODO rework other string formats in @atproto/syntax to follow this pattern\n// and re-export here, e.g. language tags, NSIDs, record keys, etc.\n\nexport {\n  type AtIdentifierString,\n  asAtIdentifierString,\n  assertAtIdentifierString,\n  ifAtIdentifierString,\n  isAtIdentifierString,\n} from '@atproto/syntax'\n\n// AtIdentifierString utilities\nexport { isDidIdentifier, isHandleIdentifier } from '@atproto/syntax'\n\nexport {\n  type DatetimeString,\n  asDatetimeString,\n  assertDatetimeString,\n  ifDatetimeString,\n  isDatetimeString,\n} from '@atproto/syntax'\n\n/**\n * Matches any ISO-ish datetime string. This is a more lenient check than\n * the strict {@link isDatetimeString} guard, which only allows datetimes that\n * fully conform to the AT Protocol specification (e.g. must include timezone).\n */\nexport function isDatetimeStringLenient<I>(\n  input: I,\n): input is I & DatetimeString {\n  // @NOTE the returned type assertion is inaccurate wrt. the DatetimeString\n  // type definition. A more accurate solution would be to use a branded type\n  // instead of a template literal for the \"datetime\" format\n  if (typeof input !== 'string') return false\n  try {\n    return isValidISODateString(input)\n  } catch {\n    // @NOTE isValidISODateString throws on some inputs\n    return false\n  }\n}\n\n// DatetimeString utilities\nexport { currentDatetimeString, toDatetimeString } from '@atproto/syntax'\n\nexport {\n  type AtUriString,\n  asAtUriString,\n  assertAtUriString,\n  ifAtUriString,\n  isAtUriString,\n} from '@atproto/syntax'\n\n/**\n * Lenient version of {@link isAtUriString} that does not enforce the validity\n * of the record key (rkey) path component (if present).\n *\n * @see {@link isAtUriString}\n */\nexport function isAtUriStringLenient<I>(input: I): input is I & AtUriString {\n  return isAtUriString(input, { strict: false })\n}\n\n/**\n * Type guard that checks if a value is a valid CID string.\n *\n * @param value - The value to check\n * @returns `true` if the value is a valid CID string\n */\nexport const isCidString = ((v) => validateCidString(v)) as CheckFn<CidString>\n/**\n * A Content Identifier (CID) string.\n *\n * CIDs are self-describing content addresses used to identify data by its hash.\n *\n * @example `\"bafyreig...\"`\n */\nexport type CidString = string\n\n/**\n * Type guard that checks if a value is a valid DID string.\n *\n * @param value - The value to check\n * @returns `true` if the value is a valid DID string\n */\nexport const isDidString: CheckFn<DidString> = isValidDid\nexport type {\n  /**\n   * A Decentralized Identifier (DID) string.\n   *\n   * DIDs are globally unique identifiers that don't require a central authority.\n   *\n   * @example `\"did:plc:1234abcd...\"` or `\"did:web:example.com\"`\n   */\n  DidString,\n}\n\n/**\n * Type guard that checks if a value is a valid handle string.\n *\n * @param value - The value to check\n * @returns `true` if the value is a valid handle string\n */\nexport const isHandleString: CheckFn<HandleString> = isValidHandle\nexport type {\n  /**\n   * A handle string - a human-readable identifier for users.\n   *\n   * @example `\"alice.bsky.social\"` or `\"bob.example.com\"`\n   */\n  HandleString,\n}\n\n/**\n * Type guard that checks if a value is a valid BCP-47 language tag.\n *\n * @param value - The value to check\n * @returns `true` if the value is a valid language string\n */\nexport const isLanguageString = isValidLanguage as CheckFn<LanguageString>\n/**\n * A BCP-47 language tag string.\n *\n * @example `\"en\"`, `\"en-US\"`, `\"zh-Hans\"`\n */\nexport type LanguageString = string\n\n/**\n * Type guard that checks if a value is a valid NSID string.\n *\n * @param value - The value to check\n * @returns `true` if the value is a valid NSID string\n */\nexport const isNsidString: CheckFn<NsidString> = isValidNsid\nexport type {\n  /**\n   * A Namespaced Identifier (NSID) string identifying a lexicon.\n   *\n   * NSIDs use reverse-domain notation to identify schemas.\n   *\n   * @example `\"app.bsky.feed.post\"`, `\"com.atproto.repo.createRecord\"`\n   */\n  NsidString,\n}\n\n/**\n * Type guard that checks if a value is a valid record key string.\n *\n * @param value - The value to check\n * @returns `true` if the value is a valid record key string\n */\nexport const isRecordKeyString: CheckFn<RecordKeyString> = isValidRecordKey\nexport type {\n  /**\n   * A record key string identifying a record within a collection.\n   *\n   * @example `\"3k2...\"` (TID format) or `\"self\"` (literal key)\n   */\n  RecordKeyString,\n}\n\n/**\n * Type guard that checks if a value is a valid TID string.\n *\n * @param value - The value to check\n * @returns `true` if the value is a valid TID string\n */\nexport const isTidString: CheckFn<TidString> = isValidTid\nexport type {\n  /**\n   * A Timestamp Identifier (TID) string.\n   *\n   * TIDs are time-based identifiers used for record keys.\n   *\n   * @example `\"3k2...\"`\n   */\n  TidString,\n}\n\n/**\n * Type guard that checks if a value is a valid URI string.\n *\n * @param value - The value to check\n * @returns `true` if the value is a valid URI string\n */\nexport const isUriString: CheckFn<UriString> = isValidUri\nexport type {\n  /**\n   * A standard URI string.\n   *\n   * @example `\"https://example.com/path\"`\n   */\n  UriString,\n}\n\n// -----------------------------------------------------------------------------\n// String format registry\n// -----------------------------------------------------------------------------\n\ntype StringFormats = {\n  'at-identifier': AtIdentifierString\n  'at-uri': AtUriString\n  cid: CidString\n  datetime: DatetimeString\n  did: DidString\n  handle: HandleString\n  language: LanguageString\n  nsid: NsidString\n  'record-key': RecordKeyString\n  tid: TidString\n  uri: UriString\n}\n\n/**\n * Union type of all valid string format names.\n */\nexport type StringFormat = Extract<keyof StringFormats, string>\n\nconst stringFormatVerifiers: {\n  readonly [K in StringFormat]: readonly [\n    strict: CheckFn<StringFormats[K]>,\n    lenient?: CheckFn<StringFormats[K]>,\n  ]\n} = /*#__PURE__*/ Object.freeze({\n  __proto__: null,\n\n  'at-identifier': [isAtIdentifierString],\n  'at-uri': [isAtUriString, isAtUriStringLenient],\n  cid: [isCidString],\n  datetime: [isDatetimeString, isDatetimeStringLenient],\n  did: [isDidString],\n  handle: [isHandleString],\n  language: [isLanguageString],\n  nsid: [isNsidString],\n  'record-key': [isRecordKeyString],\n  tid: [isTidString],\n  uri: [isUriString],\n})\n\nexport type StringFormatValidationOptions = {\n  /**\n   * Allows to be more lenient in validation by using a \"lenient\" verification\n   * function, if available. The behavior of the lenient verifier depends on the\n   * specific format, but generally it may allow for a wider range of valid\n   * inputs, including values that are not compliant with the AT Protocol\n   * specification.\n   *\n   * @default true\n   */\n  strict?: boolean\n}\n\n/**\n * Infers the string type for a given format name.\n *\n * @typeParam F - The format name\n *\n * @example\n * ```typescript\n * type Did = InferStringFormat<'did'>\n * // Result: DidString\n * ```\n */\nexport type InferStringFormat<F extends StringFormat> = F extends StringFormat\n  ? StringFormats[F]\n  : never\n\n/**\n * Type guard that checks if a string matches a specific format.\n *\n * @typeParam I - The input string type\n * @typeParam F - The format to check\n * @param input - The string to validate\n * @param format - The format name to validate against\n * @returns `true` if the string matches the format\n *\n * @example\n * ```typescript\n * const value: string = 'did:plc:1234...'\n * if (isStringFormat(value, 'did')) {\n *   // value is typed as DidString\n *   console.log('Valid DID:', value)\n * }\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function isStringFormat<I extends string, F extends StringFormat>(\n  input: I,\n  format: F,\n  options?: StringFormatValidationOptions,\n): input is I & StringFormats[F] {\n  const formatVerifier = stringFormatVerifiers[format]\n  // Fool-proof\n  if (!formatVerifier) throw new TypeError(`Unknown string format: ${format}`)\n\n  const check: CheckFn<StringFormats[F]> =\n    options?.strict === false && formatVerifier.length > 1\n      ? formatVerifier[1]!\n      : formatVerifier[0]\n\n  return check(input)\n}\n\n/**\n * Asserts that a string matches a specific format, throwing if invalid.\n *\n * @typeParam I - The input string type\n * @typeParam F - The format to check\n * @param input - The string to validate\n * @param format - The format name to validate against\n * @throws {TypeError} If the string doesn't match the format\n *\n * @example\n * ```typescript\n * assertStringFormat(value, 'handle')\n * // value is now typed as HandleString\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function assertStringFormat<I extends string, F extends StringFormat>(\n  input: I,\n  format: F,\n  options?: StringFormatValidationOptions,\n): asserts input is I & StringFormats[F] {\n  if (!isStringFormat(input, format, options)) {\n    throw new TypeError(`Invalid string format (${format}): ${input}`)\n  }\n}\n\n/**\n * Validates and returns a string as the specified format type, throwing if invalid.\n *\n * This is useful when you need to convert a string to a format type in an expression.\n *\n * @typeParam I - The input string type\n * @typeParam F - The format to validate against\n * @param input - The string to validate\n * @param format - The format name to validate against\n * @returns The input typed as the format type\n * @throws {TypeError} If the string doesn't match the format\n *\n * @example\n * ```typescript\n * const did = asStringFormat(userInput, 'did')\n * // did is typed as DidString\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function asStringFormat<I extends string, F extends StringFormat>(\n  input: I,\n  format: F,\n  options?: StringFormatValidationOptions,\n): I & StringFormats[F] {\n  assertStringFormat(input, format, options)\n  return input\n}\n\n/**\n * Returns the string as the format type if valid, otherwise returns `undefined`.\n *\n * This is useful for optional validation where you want to handle invalid values\n * without throwing.\n *\n * @typeParam I - The input string type\n * @typeParam F - The format to validate against\n * @param input - The string to validate\n * @param format - The format name to validate against\n * @returns The typed string if valid, otherwise `undefined`\n *\n * @example\n * ```typescript\n * const did = ifStringFormat(maybeInvalid, 'did')\n * if (did) {\n *   // did is typed as DidString\n * }\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function ifStringFormat<I extends string, F extends StringFormat>(\n  input: I,\n  format: F,\n  options?: StringFormatValidationOptions,\n): undefined | (I & StringFormats[F]) {\n  return isStringFormat(input, format, options) ? input : undefined\n}\n\n/**\n * Array of all valid string format names.\n *\n * @example\n * ```typescript\n * for (const format of STRING_FORMATS) {\n *   console.log(format) // 'at-identifier', 'at-uri', 'cid', ...\n * }\n * ```\n */\nexport const STRING_FORMATS = /*#__PURE__*/ Object.freeze(\n  /*#__PURE__*/ Object.keys(stringFormatVerifiers),\n) as readonly StringFormat[]\n"]}
+{"version":3,"file":"string-format.js","sourceRoot":"","sources":["../../src/core/string-format.ts"],"names":[],"mappings":"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","sourcesContent":["import isoDatestringValidator from 'iso-datestring-validator'\nconst { isValidISODateString } = isoDatestringValidator\nimport { validateCidString } from '@atproto/lex-data'\nimport {\n  AtIdentifierString,\n  AtUriString,\n  DatetimeString,\n  DidString,\n  HandleString,\n  NsidString,\n  RecordKeyString,\n  TidString,\n  UriString,\n  isAtIdentifierString,\n  isAtUriString,\n  isDatetimeString,\n  isValidDid,\n  isValidHandle,\n  isValidLanguage,\n  isValidNsid,\n  isValidRecordKey,\n  isValidTid,\n  isValidUri,\n} from '@atproto/syntax'\nimport { CheckFn } from '../util/assertion-util.js'\n\n// -----------------------------------------------------------------------------\n// Individual string format types and type guards\n// -----------------------------------------------------------------------------\n\n// Re-exporting from @atproto/syntax without modification to preserve types and\n// documentation for types and utilities that are already well-defined there.\n// @TODO rework other string formats in @atproto/syntax to follow this pattern\n// and re-export here, e.g. language tags, NSIDs, record keys, etc.\n\nexport {\n  type AtIdentifierString,\n  asAtIdentifierString,\n  assertAtIdentifierString,\n  ifAtIdentifierString,\n  isAtIdentifierString,\n} from '@atproto/syntax'\n\n// AtIdentifierString utilities\nexport { isDidIdentifier, isHandleIdentifier } from '@atproto/syntax'\n\nexport {\n  type DatetimeString,\n  asDatetimeString,\n  assertDatetimeString,\n  ifDatetimeString,\n  isDatetimeString,\n} from '@atproto/syntax'\n\n/**\n * Matches any ISO-ish datetime string. This is a more lenient check than\n * the strict {@link isDatetimeString} guard, which only allows datetimes that\n * fully conform to the AT Protocol specification (e.g. must include timezone).\n */\nexport function isDatetimeStringLenient<I>(\n  input: I,\n): input is I & DatetimeString {\n  // @NOTE the returned type assertion is inaccurate wrt. the DatetimeString\n  // type definition. A more accurate solution would be to use a branded type\n  // instead of a template literal for the \"datetime\" format\n  if (typeof input !== 'string') return false\n  try {\n    return isValidISODateString(input)\n  } catch {\n    // @NOTE isValidISODateString throws on some inputs\n    return false\n  }\n}\n\n// DatetimeString utilities\nexport { currentDatetimeString, toDatetimeString } from '@atproto/syntax'\n\nexport {\n  type AtUriString,\n  asAtUriString,\n  assertAtUriString,\n  ifAtUriString,\n  isAtUriString,\n} from '@atproto/syntax'\n\n/**\n * Lenient version of {@link isAtUriString} that does not enforce the validity\n * of the record key (rkey) path component (if present).\n *\n * @see {@link isAtUriString}\n */\nexport function isAtUriStringLenient<I>(input: I): input is I & AtUriString {\n  return isAtUriString(input, { strict: false })\n}\n\n/**\n * Type guard that checks if a value is a valid CID string.\n *\n * @param value - The value to check\n * @returns `true` if the value is a valid CID string\n */\nexport const isCidString = ((v) => validateCidString(v)) as CheckFn<CidString>\n/**\n * A Content Identifier (CID) string.\n *\n * CIDs are self-describing content addresses used to identify data by its hash.\n *\n * @example `\"bafyreig...\"`\n */\nexport type CidString = string\n\n/**\n * Type guard that checks if a value is a valid DID string.\n *\n * @param value - The value to check\n * @returns `true` if the value is a valid DID string\n */\nexport const isDidString: CheckFn<DidString> = isValidDid\nexport type {\n  /**\n   * A Decentralized Identifier (DID) string.\n   *\n   * DIDs are globally unique identifiers that don't require a central authority.\n   *\n   * @example `\"did:plc:1234abcd...\"` or `\"did:web:example.com\"`\n   */\n  DidString,\n}\n\n/**\n * Type guard that checks if a value is a valid handle string.\n *\n * @param value - The value to check\n * @returns `true` if the value is a valid handle string\n */\nexport const isHandleString: CheckFn<HandleString> = isValidHandle\nexport type {\n  /**\n   * A handle string - a human-readable identifier for users.\n   *\n   * @example `\"alice.bsky.social\"` or `\"bob.example.com\"`\n   */\n  HandleString,\n}\n\n/**\n * Type guard that checks if a value is a valid BCP-47 language tag.\n *\n * @param value - The value to check\n * @returns `true` if the value is a valid language string\n */\nexport const isLanguageString = isValidLanguage as CheckFn<LanguageString>\n/**\n * A BCP-47 language tag string.\n *\n * @example `\"en\"`, `\"en-US\"`, `\"zh-Hans\"`\n */\nexport type LanguageString = string\n\n/**\n * Type guard that checks if a value is a valid NSID string.\n *\n * @param value - The value to check\n * @returns `true` if the value is a valid NSID string\n */\nexport const isNsidString: CheckFn<NsidString> = isValidNsid\nexport type {\n  /**\n   * A Namespaced Identifier (NSID) string identifying a lexicon.\n   *\n   * NSIDs use reverse-domain notation to identify schemas.\n   *\n   * @example `\"app.bsky.feed.post\"`, `\"com.atproto.repo.createRecord\"`\n   */\n  NsidString,\n}\n\n/**\n * Type guard that checks if a value is a valid record key string.\n *\n * @param value - The value to check\n * @returns `true` if the value is a valid record key string\n */\nexport const isRecordKeyString: CheckFn<RecordKeyString> = isValidRecordKey\nexport type {\n  /**\n   * A record key string identifying a record within a collection.\n   *\n   * @example `\"3k2...\"` (TID format) or `\"self\"` (literal key)\n   */\n  RecordKeyString,\n}\n\n/**\n * Type guard that checks if a value is a valid TID string.\n *\n * @param value - The value to check\n * @returns `true` if the value is a valid TID string\n */\nexport const isTidString: CheckFn<TidString> = isValidTid\nexport type {\n  /**\n   * A Timestamp Identifier (TID) string.\n   *\n   * TIDs are time-based identifiers used for record keys.\n   *\n   * @example `\"3k2...\"`\n   */\n  TidString,\n}\n\n/**\n * Type guard that checks if a value is a valid URI string.\n *\n * @param value - The value to check\n * @returns `true` if the value is a valid URI string\n */\nexport const isUriString: CheckFn<UriString> = isValidUri\nexport type {\n  /**\n   * A standard URI string.\n   *\n   * @example `\"https://example.com/path\"`\n   */\n  UriString,\n}\n\n// -----------------------------------------------------------------------------\n// String format registry\n// -----------------------------------------------------------------------------\n\ntype StringFormats = {\n  'at-identifier': AtIdentifierString\n  'at-uri': AtUriString\n  cid: CidString\n  datetime: DatetimeString\n  did: DidString\n  handle: HandleString\n  language: LanguageString\n  nsid: NsidString\n  'record-key': RecordKeyString\n  tid: TidString\n  uri: UriString\n}\n\n/**\n * Union type of all valid string format names.\n */\nexport type StringFormat = Extract<keyof StringFormats, string>\n\nconst stringFormatVerifiers: {\n  readonly [K in StringFormat]: readonly [\n    strict: CheckFn<StringFormats[K]>,\n    lenient?: CheckFn<StringFormats[K]>,\n  ]\n} = /*#__PURE__*/ Object.freeze({\n  __proto__: null,\n\n  'at-identifier': [isAtIdentifierString],\n  'at-uri': [isAtUriString, isAtUriStringLenient],\n  cid: [isCidString],\n  datetime: [isDatetimeString, isDatetimeStringLenient],\n  did: [isDidString],\n  handle: [isHandleString],\n  language: [isLanguageString],\n  nsid: [isNsidString],\n  'record-key': [isRecordKeyString],\n  tid: [isTidString],\n  uri: [isUriString],\n})\n\nexport type StringFormatValidationOptions = {\n  /**\n   * Allows to be more lenient in validation by using a \"lenient\" verification\n   * function, if available. The behavior of the lenient verifier depends on the\n   * specific format, but generally it may allow for a wider range of valid\n   * inputs, including values that are not compliant with the AT Protocol\n   * specification.\n   *\n   * @default true\n   */\n  strict?: boolean\n}\n\n/**\n * Infers the string type for a given format name.\n *\n * @typeParam F - The format name\n *\n * @example\n * ```typescript\n * type Did = InferStringFormat<'did'>\n * // Result: DidString\n * ```\n */\nexport type InferStringFormat<F extends StringFormat> = F extends StringFormat\n  ? StringFormats[F]\n  : never\n\n/**\n * Type guard that checks if a string matches a specific format.\n *\n * @typeParam I - The input string type\n * @typeParam F - The format to check\n * @param input - The string to validate\n * @param format - The format name to validate against\n * @returns `true` if the string matches the format\n *\n * @example\n * ```typescript\n * const value: string = 'did:plc:1234...'\n * if (isStringFormat(value, 'did')) {\n *   // value is typed as DidString\n *   console.log('Valid DID:', value)\n * }\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function isStringFormat<I extends string, F extends StringFormat>(\n  input: I,\n  format: F,\n  options?: StringFormatValidationOptions,\n): input is I & StringFormats[F] {\n  const formatVerifier = stringFormatVerifiers[format]\n  // Fool-proof\n  if (!formatVerifier) throw new TypeError(`Unknown string format: ${format}`)\n\n  const check: CheckFn<StringFormats[F]> =\n    options?.strict === false && formatVerifier.length > 1\n      ? formatVerifier[1]!\n      : formatVerifier[0]\n\n  return check(input)\n}\n\n/**\n * Asserts that a string matches a specific format, throwing if invalid.\n *\n * @typeParam I - The input string type\n * @typeParam F - The format to check\n * @param input - The string to validate\n * @param format - The format name to validate against\n * @throws {TypeError} If the string doesn't match the format\n *\n * @example\n * ```typescript\n * assertStringFormat(value, 'handle')\n * // value is now typed as HandleString\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function assertStringFormat<I extends string, F extends StringFormat>(\n  input: I,\n  format: F,\n  options?: StringFormatValidationOptions,\n): asserts input is I & StringFormats[F] {\n  if (!isStringFormat(input, format, options)) {\n    throw new TypeError(`Invalid string format (${format}): ${input}`)\n  }\n}\n\n/**\n * Validates and returns a string as the specified format type, throwing if invalid.\n *\n * This is useful when you need to convert a string to a format type in an expression.\n *\n * @typeParam I - The input string type\n * @typeParam F - The format to validate against\n * @param input - The string to validate\n * @param format - The format name to validate against\n * @returns The input typed as the format type\n * @throws {TypeError} If the string doesn't match the format\n *\n * @example\n * ```typescript\n * const did = asStringFormat(userInput, 'did')\n * // did is typed as DidString\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function asStringFormat<I extends string, F extends StringFormat>(\n  input: I,\n  format: F,\n  options?: StringFormatValidationOptions,\n): I & StringFormats[F] {\n  assertStringFormat(input, format, options)\n  return input\n}\n\n/**\n * Returns the string as the format type if valid, otherwise returns `undefined`.\n *\n * This is useful for optional validation where you want to handle invalid values\n * without throwing.\n *\n * @typeParam I - The input string type\n * @typeParam F - The format to validate against\n * @param input - The string to validate\n * @param format - The format name to validate against\n * @returns The typed string if valid, otherwise `undefined`\n *\n * @example\n * ```typescript\n * const did = ifStringFormat(maybeInvalid, 'did')\n * if (did) {\n *   // did is typed as DidString\n * }\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function ifStringFormat<I extends string, F extends StringFormat>(\n  input: I,\n  format: F,\n  options?: StringFormatValidationOptions,\n): undefined | (I & StringFormats[F]) {\n  return isStringFormat(input, format, options) ? input : undefined\n}\n\n/**\n * Array of all valid string format names.\n *\n * @example\n * ```typescript\n * for (const format of STRING_FORMATS) {\n *   console.log(format) // 'at-identifier', 'at-uri', 'cid', ...\n * }\n * ```\n */\nexport const STRING_FORMATS = /*#__PURE__*/ Object.freeze(\n  /*#__PURE__*/ Object.keys(stringFormatVerifiers),\n) as readonly StringFormat[]\n"]}

package/dist/core/types.js

@@ -1,3 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};
 //# sourceMappingURL=types.js.map

package/dist/core/validation-error.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LexValidationError = void 0;
-const lex_data_1 = require("@atproto/lex-data");
-const array_agg_js_1 = require("../util/array-agg.js");
-const result_js_1 = require("./result.js");
-const validation_issue_js_1 = require("./validation-issue.js");
+import { LexError } from '@atproto/lex-data';
+import { arrayAgg } from '../util/array-agg.js';
+import { failureReason } from './result.js';
+import { IssueInvalidType, IssueInvalidValue, } from './validation-issue.js';
 /**
  * Error thrown when validation fails.
  *
@@ -32,15 +29,7 @@ const validation_issue_js_1 = require("./validation-issue.js");
  * directly as a failure reason in validation results, avoiding the need for
  * wrapping it in an additional object.
  */
-class LexValidationError extends lex_data_1.LexError {
-    name = 'LexValidationError';
-    /**
-     * The list of validation issues that caused this error.
-     *
-     * Issues are aggregated when possible (e.g., multiple invalid type issues
-     * at the same path are combined into a single issue listing all expected types).
-     */
-    issues;
+export class LexValidationError extends LexError {
     /**
      * Creates a new validation error from a list of issues.
      *
@@ -53,10 +42,11 @@ class LexValidationError extends lex_data_1.LexError {
     constructor(issues, options) {
         const issuesAgg = aggregateIssues(issues);
         super('InvalidRequest', issuesAgg.join(', '), options);
+        this.name = 'LexValidationError';
+        /** @see {ResultFailure.success} */
+        this.success = false;
         this.issues = issuesAgg;
     }
-    /** @see {ResultFailure.success} */
-    success = false;
     /** @see {ResultFailure.reason} */
     get reason() {
         return this;
@@ -91,15 +81,14 @@ class LexValidationError extends lex_data_1.LexError {
      */
     static fromFailures(failures) {
         if (failures.length === 1)
-            return (0, result_js_1.failureReason)(failures[0]);
+            return failureReason(failures[0]);
         const issues = failures.flatMap(extractFailureIssues);
         return new LexValidationError(issues, {
             // Keep the original errors as the cause chain
-            cause: failures.map(result_js_1.failureReason),
+            cause: failures.map(failureReason),
         });
     }
 }
-exports.LexValidationError = LexValidationError;
 function extractFailureIssues(result) {
     return result.reason.issues;
 }
@@ -111,12 +100,12 @@ function aggregateIssues(issues) {
         return issues;
     return [
         // Aggregate invalid_type with identical paths
-        ...(0, array_agg_js_1.arrayAgg)(issues.filter((issue) => issue instanceof validation_issue_js_1.IssueInvalidType), (a, b) => comparePropertyPaths(a.path, b.path), (issues) => new validation_issue_js_1.IssueInvalidType(issues[0].path, issues[0].input, Array.from(new Set(issues.flatMap((iss) => iss.expected))))),
+        ...arrayAgg(issues.filter((issue) => issue instanceof IssueInvalidType), (a, b) => comparePropertyPaths(a.path, b.path), (issues) => new IssueInvalidType(issues[0].path, issues[0].input, Array.from(new Set(issues.flatMap((iss) => iss.expected))))),
         // Aggregate invalid_value with identical paths
-        ...(0, array_agg_js_1.arrayAgg)(issues.filter((issue) => issue instanceof validation_issue_js_1.IssueInvalidValue), (a, b) => comparePropertyPaths(a.path, b.path), (issues) => new validation_issue_js_1.IssueInvalidValue(issues[0].path, issues[0].input, Array.from(new Set(issues.flatMap((iss) => iss.values))))),
+        ...arrayAgg(issues.filter((issue) => issue instanceof IssueInvalidValue), (a, b) => comparePropertyPaths(a.path, b.path), (issues) => new IssueInvalidValue(issues[0].path, issues[0].input, Array.from(new Set(issues.flatMap((iss) => iss.values))))),
         // Pass through other issues
-        ...issues.filter((issue) => !(issue instanceof validation_issue_js_1.IssueInvalidType) &&
-            !(issue instanceof validation_issue_js_1.IssueInvalidValue)),
+        ...issues.filter((issue) => !(issue instanceof IssueInvalidType) &&
+            !(issue instanceof IssueInvalidValue)),
     ];
 }
 /*@__NO_SIDE_EFFECTS__*/

package/dist/core/validation-error.js.map

@@ -1 +1 @@
-{"version":3,"file":"validation-error.js","sourceRoot":"","sources":["../../src/core/validation-error.ts"],"names":[],"mappings":"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","sourcesContent":["import { LexError } from '@atproto/lex-data'\nimport { arrayAgg } from '../util/array-agg.js'\nimport { ResultFailure, failureReason } from './result.js'\nimport {\n  Issue,\n  IssueInvalidType,\n  IssueInvalidValue,\n} from './validation-issue.js'\n\n/**\n * Error thrown when validation fails.\n *\n * Contains detailed information about all validation issues encountered,\n * including the path to each invalid value and descriptions of what was\n * expected vs what was received.\n *\n * Extends {@link LexError} with the error name \"InvalidRequest\" for\n * consistency with the AT Protocol error handling conventions.\n *\n * @example\n * ```typescript\n * const error = new LexValidationError([\n *   new IssueInvalidType(['user', 'age'], 'hello', ['number'])\n * ])\n * console.log(error.message)\n * // \"Expected integer value type (got \"some-string\") at $.user.age\"\n *\n * console.log(error.issues.length) // 1\n * console.log(error.toJSON())\n * // { error: 'InvalidRequest', message: '...', issues: [...] }\n * ```\n *\n * @note this class implements {@link ResultFailure} to allow it to be used\n * directly as a failure reason in validation results, avoiding the need for\n * wrapping it in an additional object.\n */\nexport class LexValidationError\n  extends LexError<'InvalidRequest'>\n  implements ResultFailure<LexValidationError>\n{\n  name = 'LexValidationError'\n\n  /**\n   * The list of validation issues that caused this error.\n   *\n   * Issues are aggregated when possible (e.g., multiple invalid type issues\n   * at the same path are combined into a single issue listing all expected types).\n   */\n  readonly issues: readonly Issue[]\n\n  /**\n   * Creates a new validation error from a list of issues.\n   *\n   * Issues are automatically aggregated to combine related issues at the same\n   * path (e.g., multiple type expectations from a union schema).\n   *\n   * @param issues - The validation issues that caused this error\n   * @param options - Standard Error options (e.g., `cause`)\n   */\n  constructor(issues: Issue[], options?: ErrorOptions) {\n    const issuesAgg = aggregateIssues(issues)\n    super('InvalidRequest', issuesAgg.join(', '), options)\n    this.issues = issuesAgg\n  }\n\n  /** @see {ResultFailure.success} */\n  readonly success = false as const\n\n  /** @see {ResultFailure.reason} */\n  get reason() {\n    return this\n  }\n\n  /**\n   * Converts the error to a JSON-serializable object.\n   *\n   * @returns An object containing the error details and issues details\n   */\n  override toJSON() {\n    return {\n      ...super.toJSON(),\n      issues: this.issues.map((issue) => issue.toJSON()),\n    }\n  }\n\n  /**\n   * Creates a validation error by combining multiple validation failures.\n   *\n   * This is useful when validating against multiple possible schemas (e.g., unions)\n   * and all branches fail. The resulting error contains issues from all failures.\n   *\n   * @param failures - The validation failures to combine\n   * @returns A single validation error containing all issues from the failures\n   *\n   * @example\n   * ```typescript\n   * const failures = schemas.map(s => s.safeValidate(data)).filter(r => !r.success)\n   * if (failures.length === schemas.length) {\n   *   throw LexValidationError.fromFailures(failures)\n   * }\n   * ```\n   */\n  static fromFailures(\n    failures: readonly ResultFailure<LexValidationError>[],\n  ): LexValidationError {\n    if (failures.length === 1) return failureReason(failures[0])\n    const issues = failures.flatMap(extractFailureIssues)\n    return new LexValidationError(issues, {\n      // Keep the original errors as the cause chain\n      cause: failures.map(failureReason),\n    })\n  }\n}\n\nfunction extractFailureIssues(result: ResultFailure<LexValidationError>) {\n  return result.reason.issues\n}\n\nfunction aggregateIssues(issues: Issue[]): Issue[] {\n  // Quick path for common cases\n  if (issues.length <= 1) return issues\n  if (issues.length === 2 && issues[0].code !== issues[1].code) return issues\n\n  return [\n    // Aggregate invalid_type with identical paths\n    ...arrayAgg(\n      issues.filter((issue) => issue instanceof IssueInvalidType),\n      (a, b) => comparePropertyPaths(a.path, b.path),\n      (issues) =>\n        new IssueInvalidType(\n          issues[0].path,\n          issues[0].input,\n          Array.from(new Set(issues.flatMap((iss) => iss.expected))),\n        ),\n    ),\n    // Aggregate invalid_value with identical paths\n    ...arrayAgg(\n      issues.filter((issue) => issue instanceof IssueInvalidValue),\n      (a, b) => comparePropertyPaths(a.path, b.path),\n      (issues) =>\n        new IssueInvalidValue(\n          issues[0].path,\n          issues[0].input,\n          Array.from(new Set(issues.flatMap((iss) => iss.values))),\n        ),\n    ),\n    // Pass through other issues\n    ...issues.filter(\n      (issue) =>\n        !(issue instanceof IssueInvalidType) &&\n        !(issue instanceof IssueInvalidValue),\n    ),\n  ]\n}\n\n/*@__NO_SIDE_EFFECTS__*/\nfunction comparePropertyPaths(\n  a: readonly PropertyKey[],\n  b: readonly PropertyKey[],\n) {\n  if (a.length !== b.length) return false\n  for (let i = 0; i < a.length; i++) {\n    if (a[i] !== b[i]) return false\n  }\n  return true\n}\n"]}
+{"version":3,"file":"validation-error.js","sourceRoot":"","sources":["../../src/core/validation-error.ts"],"names":[],"mappings":"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","sourcesContent":["import { LexError } from '@atproto/lex-data'\nimport { arrayAgg } from '../util/array-agg.js'\nimport { ResultFailure, failureReason } from './result.js'\nimport {\n  Issue,\n  IssueInvalidType,\n  IssueInvalidValue,\n} from './validation-issue.js'\n\n/**\n * Error thrown when validation fails.\n *\n * Contains detailed information about all validation issues encountered,\n * including the path to each invalid value and descriptions of what was\n * expected vs what was received.\n *\n * Extends {@link LexError} with the error name \"InvalidRequest\" for\n * consistency with the AT Protocol error handling conventions.\n *\n * @example\n * ```typescript\n * const error = new LexValidationError([\n *   new IssueInvalidType(['user', 'age'], 'hello', ['number'])\n * ])\n * console.log(error.message)\n * // \"Expected integer value type (got \"some-string\") at $.user.age\"\n *\n * console.log(error.issues.length) // 1\n * console.log(error.toJSON())\n * // { error: 'InvalidRequest', message: '...', issues: [...] }\n * ```\n *\n * @note this class implements {@link ResultFailure} to allow it to be used\n * directly as a failure reason in validation results, avoiding the need for\n * wrapping it in an additional object.\n */\nexport class LexValidationError\n  extends LexError<'InvalidRequest'>\n  implements ResultFailure<LexValidationError>\n{\n  name = 'LexValidationError'\n\n  /**\n   * The list of validation issues that caused this error.\n   *\n   * Issues are aggregated when possible (e.g., multiple invalid type issues\n   * at the same path are combined into a single issue listing all expected types).\n   */\n  readonly issues: readonly Issue[]\n\n  /**\n   * Creates a new validation error from a list of issues.\n   *\n   * Issues are automatically aggregated to combine related issues at the same\n   * path (e.g., multiple type expectations from a union schema).\n   *\n   * @param issues - The validation issues that caused this error\n   * @param options - Standard Error options (e.g., `cause`)\n   */\n  constructor(issues: Issue[], options?: ErrorOptions) {\n    const issuesAgg = aggregateIssues(issues)\n    super('InvalidRequest', issuesAgg.join(', '), options)\n    this.issues = issuesAgg\n  }\n\n  /** @see {ResultFailure.success} */\n  readonly success = false as const\n\n  /** @see {ResultFailure.reason} */\n  get reason() {\n    return this\n  }\n\n  /**\n   * Converts the error to a JSON-serializable object.\n   *\n   * @returns An object containing the error details and issues details\n   */\n  override toJSON() {\n    return {\n      ...super.toJSON(),\n      issues: this.issues.map((issue) => issue.toJSON()),\n    }\n  }\n\n  /**\n   * Creates a validation error by combining multiple validation failures.\n   *\n   * This is useful when validating against multiple possible schemas (e.g., unions)\n   * and all branches fail. The resulting error contains issues from all failures.\n   *\n   * @param failures - The validation failures to combine\n   * @returns A single validation error containing all issues from the failures\n   *\n   * @example\n   * ```typescript\n   * const failures = schemas.map(s => s.safeValidate(data)).filter(r => !r.success)\n   * if (failures.length === schemas.length) {\n   *   throw LexValidationError.fromFailures(failures)\n   * }\n   * ```\n   */\n  static fromFailures(\n    failures: readonly ResultFailure<LexValidationError>[],\n  ): LexValidationError {\n    if (failures.length === 1) return failureReason(failures[0])\n    const issues = failures.flatMap(extractFailureIssues)\n    return new LexValidationError(issues, {\n      // Keep the original errors as the cause chain\n      cause: failures.map(failureReason),\n    })\n  }\n}\n\nfunction extractFailureIssues(result: ResultFailure<LexValidationError>) {\n  return result.reason.issues\n}\n\nfunction aggregateIssues(issues: Issue[]): Issue[] {\n  // Quick path for common cases\n  if (issues.length <= 1) return issues\n  if (issues.length === 2 && issues[0].code !== issues[1].code) return issues\n\n  return [\n    // Aggregate invalid_type with identical paths\n    ...arrayAgg(\n      issues.filter((issue) => issue instanceof IssueInvalidType),\n      (a, b) => comparePropertyPaths(a.path, b.path),\n      (issues) =>\n        new IssueInvalidType(\n          issues[0].path,\n          issues[0].input,\n          Array.from(new Set(issues.flatMap((iss) => iss.expected))),\n        ),\n    ),\n    // Aggregate invalid_value with identical paths\n    ...arrayAgg(\n      issues.filter((issue) => issue instanceof IssueInvalidValue),\n      (a, b) => comparePropertyPaths(a.path, b.path),\n      (issues) =>\n        new IssueInvalidValue(\n          issues[0].path,\n          issues[0].input,\n          Array.from(new Set(issues.flatMap((iss) => iss.values))),\n        ),\n    ),\n    // Pass through other issues\n    ...issues.filter(\n      (issue) =>\n        !(issue instanceof IssueInvalidType) &&\n        !(issue instanceof IssueInvalidValue),\n    ),\n  ]\n}\n\n/*@__NO_SIDE_EFFECTS__*/\nfunction comparePropertyPaths(\n  a: readonly PropertyKey[],\n  b: readonly PropertyKey[],\n) {\n  if (a.length !== b.length) return false\n  for (let i = 0; i < a.length; i++) {\n    if (a[i] !== b[i]) return false\n  }\n  return true\n}\n"]}

package/dist/core/validation-issue.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IssueTooSmall = exports.IssueTooBig = exports.IssueRequiredKey = exports.IssueInvalidValue = exports.IssueInvalidType = exports.IssueInvalidFormat = exports.IssueCustom = exports.Issue = void 0;
-const lex_data_1 = require("@atproto/lex-data");
-const STRING_PREVIEW_MAX_LENGTH = 48;
+import { ifCid, isLegacyBlobRef, isPlainObject } from '@atproto/lex-data';
+const STRING_PREVIEW_MAX_LENGTH = 256;
 const STRING_PREVIEW_TRUNCATED_SUFFIX = '…';
 /**
  * Abstract base class for all validation issues.
@@ -16,10 +13,7 @@ const STRING_PREVIEW_TRUNCATED_SUFFIX = '…';
  * the {@link message} property for human-readable error messages (that don't
  * contain the error path)
  */
-class Issue {
-    code;
-    path;
-    input;
+export class Issue {
     constructor(code, path, input) {
         this.code = code;
         this.path = path;
@@ -44,16 +38,12 @@ class Issue {
         };
     }
 }
-exports.Issue = Issue;
 /**
  * A custom validation issue with a user-defined message.
  *
  * Use this for validation rules that don't fit into the standard issue categories.
  */
-class IssueCustom extends Issue {
-    path;
-    input;
-    message;
+export class IssueCustom extends Issue {
     constructor(path, input, message) {
         super('custom', path, input);
         this.path = path;
@@ -61,15 +51,12 @@ class IssueCustom extends Issue {
         this.message = message;
     }
 }
-exports.IssueCustom = IssueCustom;
 /**
  * Issue for string values that don't match an expected format.
  *
  * Used for AT Protocol specific formats like DID, handle, NSID, AT-URI, etc.
  */
-class IssueInvalidFormat extends Issue {
-    format;
-    detail;
+export class IssueInvalidFormat extends Issue {
     constructor(path, input, format, detail) {
         super('invalid_format', path, input);
         this.format = format;
@@ -104,15 +91,13 @@ class IssueInvalidFormat extends Issue {
         };
     }
 }
-exports.IssueInvalidFormat = IssueInvalidFormat;
 /**
  * Issue for values that have an unexpected type.
  *
  * This is one of the most common validation issues, occurring when the
  * runtime type of a value doesn't match the expected schema type.
  */
-class IssueInvalidType extends Issue {
-    expected;
+export class IssueInvalidType extends Issue {
     constructor(path, input, expected) {
         super('invalid_type', path, input);
         this.expected = expected;
@@ -127,15 +112,13 @@ class IssueInvalidType extends Issue {
         };
     }
 }
-exports.IssueInvalidType = IssueInvalidType;
 /**
  * Issue for values that don't match any of the expected literal values.
  *
  * Used when a value must be one of a specific set of allowed values
  * (e.g., enum-like constraints).
  */
-class IssueInvalidValue extends Issue {
-    values;
+export class IssueInvalidValue extends Issue {
     constructor(path, input, values) {
         super('invalid_value', path, input);
         this.values = values;
@@ -150,12 +133,10 @@ class IssueInvalidValue extends Issue {
         };
     }
 }
-exports.IssueInvalidValue = IssueInvalidValue;
 /**
  * Issue for missing required object properties.
  */
-class IssueRequiredKey extends Issue {
-    key;
+export class IssueRequiredKey extends Issue {
     constructor(path, input, key) {
         super('required_key', path, input);
         this.key = key;
@@ -170,14 +151,10 @@ class IssueRequiredKey extends Issue {
         };
     }
 }
-exports.IssueRequiredKey = IssueRequiredKey;
 /**
  * Issue for values that exceed a maximum constraint.
  */
-class IssueTooBig extends Issue {
-    maximum;
-    type;
-    actual;
+export class IssueTooBig extends Issue {
     constructor(path, input, maximum, type, actual) {
         super('too_big', path, input);
         this.maximum = maximum;
@@ -195,14 +172,10 @@ class IssueTooBig extends Issue {
         };
     }
 }
-exports.IssueTooBig = IssueTooBig;
 /**
  * Issue for values that are below a minimum constraint.
  */
-class IssueTooSmall extends Issue {
-    minimum;
-    type;
-    actual;
+export class IssueTooSmall extends Issue {
     constructor(path, input, minimum, type, actual) {
         super('too_small', path, input);
         this.minimum = minimum;
@@ -220,7 +193,6 @@ class IssueTooSmall extends Issue {
         };
     }
 }
-exports.IssueTooSmall = IssueTooSmall;
 // -----------------------------------------------------------------------------
 // Helper functions for formatting error messages
 // -----------------------------------------------------------------------------
@@ -271,12 +243,12 @@ function stringifyValue(value) {
             if (Array.isArray(value)) {
                 return `[${stringifyArray(value, stringifyValue)}]`;
             }
-            if ((0, lex_data_1.isPlainObject)(value)) {
+            if (isPlainObject(value)) {
                 return `{${stringifyArray(Object.entries(value), stringifyObjectEntry)}}`;
             }
-            if ((0, lex_data_1.ifCid)(value))
+            if (ifCid(value))
                 return 'cid';
-            if ((0, lex_data_1.isLegacyBlobRef)(value))
+            if (isLegacyBlobRef(value))
                 return 'legacy-blob';
             if (value instanceof Date)
                 return 'date';