@devp0nt/error0 1.0.0-next.5 → 1.0.0-next.50

package/dist/cjs/plugins/cause-serialize.cjs

@@ -0,0 +1,41 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cause_serialize_exports = {};
+__export(cause_serialize_exports, {
+  causeSerializePlugin: () => causeSerializePlugin
+});
+module.exports = __toCommonJS(cause_serialize_exports);
+var import__ = require('../index.cjs');
+const causeSerializePlugin = ({ hideWhenPublic = true } = {}) => import__.Error0.plugin().cause({
+  serialize: ({ value, error, isPublic }) => {
+    if (hideWhenPublic && isPublic) {
+      return void 0;
+    }
+    const ctor = error.constructor;
+    if (ctor.is(value)) {
+      return ctor.serialize(value, isPublic);
+    }
+    return void 0;
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  causeSerializePlugin
+});
+//# sourceMappingURL=cause-serialize.cjs.map

package/dist/cjs/plugins/cause-serialize.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/plugins/cause-serialize.ts"],"sourcesContent":["import { Error0 } from '../index.js'\n\nexport const causeSerializePlugin = ({ hideWhenPublic = true }: { hideWhenPublic?: boolean } = {}) =>\n  Error0.plugin().cause({\n    serialize: ({ value, error, isPublic }) => {\n      if (hideWhenPublic && isPublic) {\n        return undefined\n      }\n      const ctor = error.constructor as typeof Error0\n      if (ctor.is(value)) {\n        return ctor.serialize(value, isPublic)\n      }\n      return undefined\n    },\n  })\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,eAAuB;AAEhB,MAAM,uBAAuB,CAAC,EAAE,iBAAiB,KAAK,IAAkC,CAAC,MAC9F,gBAAO,OAAO,EAAE,MAAM;AAAA,EACpB,WAAW,CAAC,EAAE,OAAO,OAAO,SAAS,MAAM;AACzC,QAAI,kBAAkB,UAAU;AAC9B,aAAO;AAAA,IACT;AACA,UAAM,OAAO,MAAM;AACnB,QAAI,KAAK,GAAG,KAAK,GAAG;AAClB,aAAO,KAAK,UAAU,OAAO,QAAQ;AAAA,IACvC;AACA,WAAO;AAAA,EACT;AACF,CAAC;","names":[]}

package/dist/cjs/plugins/cause-serialize.d.cts

@@ -0,0 +1,7 @@
+import { PluginError0 } from '../index.cjs';
+
+declare const causeSerializePlugin: ({ hideWhenPublic }?: {
+    hideWhenPublic?: boolean;
+}) => PluginError0<Record<never, never>, Record<never, never>>;
+
+export { causeSerializePlugin };

package/dist/cjs/plugins/code.cjs

@@ -0,0 +1,38 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var code_exports = {};
+__export(code_exports, {
+  codePlugin: () => codePlugin
+});
+module.exports = __toCommonJS(code_exports);
+var import__ = require('../index.cjs');
+const codePlugin = ({ codes } = {}) => {
+  const isCode = (value) => typeof value === "string" && (!codes || codes.includes(value));
+  return import__.Error0.plugin().prop("code", {
+    init: (code) => code,
+    resolve: ({ flow }) => flow.find(Boolean),
+    serialize: ({ resolved, isPublic }) => resolved,
+    deserialize: ({ value, record }) => isCode(value) ? value : void 0
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  codePlugin
+});
+//# sourceMappingURL=code.cjs.map

package/dist/cjs/plugins/code.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/plugins/code.ts"],"sourcesContent":["import { Error0 } from '../index.js'\n\nexport const codePlugin = <TCode extends string>({ codes }: { codes?: TCode[] } = {}) => {\n  const isCode = (value: unknown): value is TCode =>\n    typeof value === 'string' && (!codes || codes.includes(value as TCode))\n  return Error0.plugin().prop('code', {\n    init: (code: TCode) => code,\n    resolve: ({ flow }) => flow.find(Boolean),\n    serialize: ({ resolved, isPublic }) => resolved,\n    deserialize: ({ value, record }) => (isCode(value) ? value : undefined),\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,eAAuB;AAEhB,MAAM,aAAa,CAAuB,EAAE,MAAM,IAAyB,CAAC,MAAM;AACvF,QAAM,SAAS,CAAC,UACd,OAAO,UAAU,aAAa,CAAC,SAAS,MAAM,SAAS,KAAc;AACvE,SAAO,gBAAO,OAAO,EAAE,KAAK,QAAQ;AAAA,IAClC,MAAM,CAAC,SAAgB;AAAA,IACvB,SAAS,CAAC,EAAE,KAAK,MAAM,KAAK,KAAK,OAAO;AAAA,IACxC,WAAW,CAAC,EAAE,UAAU,SAAS,MAAM;AAAA,IACvC,aAAa,CAAC,EAAE,OAAO,OAAO,MAAO,OAAO,KAAK,IAAI,QAAQ;AAAA,EAC/D,CAAC;AACH;","names":[]}

package/dist/cjs/plugins/code.d.cts

@@ -0,0 +1,7 @@
+import { PluginError0, ErrorPluginPropOptions, Error0 } from '../index.cjs';
+
+declare const codePlugin: <TCode extends string>({ codes }?: {
+    codes?: TCode[];
+}) => PluginError0<Record<never, never> & Record<"code", ErrorPluginPropOptions<TCode, TCode, Error0, TCode | undefined>>, Record<never, never>>;
+
+export { codePlugin };

package/dist/cjs/plugins/expected.cjs

@@ -0,0 +1,54 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var expected_exports = {};
+__export(expected_exports, {
+  expectedPlugin: () => expectedPlugin
+});
+module.exports = __toCommonJS(expected_exports);
+var import__ = require('../index.cjs');
+const isExpected = (flow) => {
+  let expected = false;
+  for (const value of flow) {
+    if (value === false) {
+      return false;
+    }
+    if (value === true) {
+      expected = true;
+    }
+  }
+  return expected;
+};
+const expectedPlugin = ({ hideWhenPublic = true } = {}) => import__.Error0.plugin().prop("expected", {
+  init: (input) => input,
+  resolve: ({ flow }) => isExpected(flow),
+  serialize: ({ resolved, isPublic }) => {
+    if (hideWhenPublic && isPublic) {
+      return void 0;
+    }
+    return resolved;
+  },
+  deserialize: ({ value }) => typeof value === "boolean" ? value : void 0
+}).method("isExpected", (error) => {
+  return isExpected(error.flow("expected"));
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  expectedPlugin
+});
+//# sourceMappingURL=expected.cjs.map

package/dist/cjs/plugins/expected.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/plugins/expected.ts"],"sourcesContent":["import { Error0 } from '../index.js'\n\nconst isExpected = (flow: unknown[]) => {\n  let expected = false\n  for (const value of flow) {\n    if (value === false) {\n      return false\n    }\n    if (value === true) {\n      expected = true\n    }\n  }\n  return expected\n}\n\nexport const expectedPlugin = ({ hideWhenPublic = true }: { hideWhenPublic?: boolean } = {}) =>\n  Error0.plugin()\n    .prop('expected', {\n      init: (input: boolean) => input,\n      resolve: ({ flow }) => isExpected(flow),\n      serialize: ({ resolved, isPublic }) => {\n        if (hideWhenPublic && isPublic) {\n          return undefined\n        }\n        return resolved\n      },\n      deserialize: ({ value }) => (typeof value === 'boolean' ? value : undefined),\n    })\n    .method('isExpected', (error) => {\n      return isExpected(error.flow('expected'))\n    })\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,eAAuB;AAEvB,MAAM,aAAa,CAAC,SAAoB;AACtC,MAAI,WAAW;AACf,aAAW,SAAS,MAAM;AACxB,QAAI,UAAU,OAAO;AACnB,aAAO;AAAA,IACT;AACA,QAAI,UAAU,MAAM;AAClB,iBAAW;AAAA,IACb;AAAA,EACF;AACA,SAAO;AACT;AAEO,MAAM,iBAAiB,CAAC,EAAE,iBAAiB,KAAK,IAAkC,CAAC,MACxF,gBAAO,OAAO,EACX,KAAK,YAAY;AAAA,EAChB,MAAM,CAAC,UAAmB;AAAA,EAC1B,SAAS,CAAC,EAAE,KAAK,MAAM,WAAW,IAAI;AAAA,EACtC,WAAW,CAAC,EAAE,UAAU,SAAS,MAAM;AACrC,QAAI,kBAAkB,UAAU;AAC9B,aAAO;AAAA,IACT;AACA,WAAO;AAAA,EACT;AAAA,EACA,aAAa,CAAC,EAAE,MAAM,MAAO,OAAO,UAAU,YAAY,QAAQ;AACpE,CAAC,EACA,OAAO,cAAc,CAAC,UAAU;AAC/B,SAAO,WAAW,MAAM,KAAK,UAAU,CAAC;AAC1C,CAAC;","names":[]}

package/dist/cjs/plugins/expected.d.cts

@@ -0,0 +1,36 @@
+import { PluginError0, ErrorPluginPropOptions, Error0 } from '../index.cjs';
+
+declare const expectedPlugin: ({ hideWhenPublic }?: {
+    hideWhenPublic?: boolean;
+}) => PluginError0<Record<never, never> & Record<"expected", ErrorPluginPropOptions<boolean, boolean, Error0, boolean>>, Record<never, never> & Record<"isExpected", (error: Error0 & {
+    expected: boolean;
+} & {} & {
+    own: {
+        (): {
+            expected: boolean | undefined;
+        };
+        <TKey extends "expected">(key: TKey): {
+            expected: boolean | undefined;
+        }[TKey];
+    };
+    flow: <TKey extends "expected">(key: TKey) => {
+        expected: boolean | undefined;
+    }[TKey][];
+} & {
+    resolve: () => {
+        expected: boolean;
+    };
+} & {
+    readonly __pluginsMap?: {
+        props: {
+            expected: {
+                init: boolean | undefined;
+                output: boolean;
+                resolve: boolean;
+            };
+        };
+        methods: {};
+    } | undefined;
+}) => boolean>>;
+
+export { expectedPlugin };

package/dist/cjs/plugins/message-merge.cjs

@@ -0,0 +1,39 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var message_merge_exports = {};
+__export(message_merge_exports, {
+  messageMergePlugin: () => messageMergePlugin
+});
+module.exports = __toCommonJS(message_merge_exports);
+var import__ = require('../index.cjs');
+const messageMergePlugin = ({
+  delimiter = ": ",
+  fallback = "Unknown error"
+} = {}) => import__.Error0.plugin().use("message", {
+  serialize: ({ error }) => {
+    return error.causes().map((cause) => {
+      return cause instanceof Error ? cause.message : void 0;
+    }).filter((value) => typeof value === "string").join(delimiter) || fallback;
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  messageMergePlugin
+});
+//# sourceMappingURL=message-merge.cjs.map

package/dist/cjs/plugins/message-merge.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/plugins/message-merge.ts"],"sourcesContent":["import { Error0 } from '../index.js'\n\nexport const messageMergePlugin = ({\n  delimiter = ': ',\n  fallback = 'Unknown error',\n}: { delimiter?: string; fallback?: string } = {}) =>\n  Error0.plugin().use('message', {\n    serialize: ({ error }) => {\n      return (\n        error\n          .causes()\n          .map((cause) => {\n            return cause instanceof Error ? cause.message : undefined\n          })\n          .filter((value): value is string => typeof value === 'string')\n          .join(delimiter) || fallback\n      )\n    },\n  })\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,eAAuB;AAEhB,MAAM,qBAAqB,CAAC;AAAA,EACjC,YAAY;AAAA,EACZ,WAAW;AACb,IAA+C,CAAC,MAC9C,gBAAO,OAAO,EAAE,IAAI,WAAW;AAAA,EAC7B,WAAW,CAAC,EAAE,MAAM,MAAM;AACxB,WACE,MACG,OAAO,EACP,IAAI,CAAC,UAAU;AACd,aAAO,iBAAiB,QAAQ,MAAM,UAAU;AAAA,IAClD,CAAC,EACA,OAAO,CAAC,UAA2B,OAAO,UAAU,QAAQ,EAC5D,KAAK,SAAS,KAAK;AAAA,EAE1B;AACF,CAAC;","names":[]}

package/dist/cjs/plugins/message-merge.d.cts

@@ -0,0 +1,8 @@
+import { PluginError0 } from '../index.cjs';
+
+declare const messageMergePlugin: ({ delimiter, fallback, }?: {
+    delimiter?: string;
+    fallback?: string;
+}) => PluginError0<Record<never, never>, Record<never, never>>;
+
+export { messageMergePlugin };

package/dist/cjs/plugins/meta.cjs

@@ -0,0 +1,78 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var meta_exports = {};
+__export(meta_exports, {
+  metaPlugin: () => metaPlugin
+});
+module.exports = __toCommonJS(meta_exports);
+var import__ = require('../index.cjs');
+const toJsonSafe = (input) => {
+  if (input === null) {
+    return null;
+  }
+  if (typeof input === "string" || typeof input === "number" || typeof input === "boolean") {
+    return input;
+  }
+  if (Array.isArray(input)) {
+    return input.map((value) => toJsonSafe(value));
+  }
+  if (typeof input === "object") {
+    const output = {};
+    for (const [key, value] of Object.entries(input)) {
+      const jsonValue = toJsonSafe(value);
+      if (jsonValue !== void 0) {
+        output[key] = jsonValue;
+      }
+    }
+    return output;
+  }
+  return void 0;
+};
+const isMetaRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const metaPlugin = ({ hideWhenPublic = true } = {}) => import__.Error0.plugin().prop("meta", {
+  init: (input) => input,
+  resolve: ({ flow }) => {
+    const values = flow.filter(isMetaRecord);
+    if (values.length === 0) {
+      return void 0;
+    }
+    const merged = {};
+    for (const value of [...values].reverse()) {
+      Object.assign(merged, value);
+    }
+    return merged;
+  },
+  serialize: ({ resolved, isPublic }) => {
+    if (hideWhenPublic && isPublic) {
+      return void 0;
+    }
+    return toJsonSafe(resolved);
+  },
+  deserialize: ({ value }) => {
+    if (!isMetaRecord(value)) {
+      return void 0;
+    }
+    return value;
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  metaPlugin
+});
+//# sourceMappingURL=meta.cjs.map

package/dist/cjs/plugins/meta.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/plugins/meta.ts"],"sourcesContent":["import { Error0 } from '../index.js'\n\ntype Json = null | boolean | number | string | Json[] | { [key: string]: Json }\n\nconst toJsonSafe = (input: unknown): Json | undefined => {\n  if (input === null) {\n    return null\n  }\n  if (typeof input === 'string' || typeof input === 'number' || typeof input === 'boolean') {\n    return input\n  }\n  if (Array.isArray(input)) {\n    return input.map((value) => toJsonSafe(value)) as Json[]\n  }\n  if (typeof input === 'object') {\n    const output: Record<string, Json> = {}\n    for (const [key, value] of Object.entries(input as Record<string, unknown>)) {\n      const jsonValue = toJsonSafe(value)\n      if (jsonValue !== undefined) {\n        output[key] = jsonValue\n      }\n    }\n    return output\n  }\n  return undefined\n}\n\nconst isMetaRecord = (value: unknown): value is Record<string, unknown> =>\n  typeof value === 'object' && value !== null && !Array.isArray(value)\n\nexport const metaPlugin = ({ hideWhenPublic = true }: { hideWhenPublic?: boolean } = {}) =>\n  Error0.plugin().prop('meta', {\n    init: (input: Record<string, unknown>) => input,\n    resolve: ({ flow }) => {\n      const values = flow.filter(isMetaRecord)\n      if (values.length === 0) {\n        return undefined\n      }\n\n      // Merge cause meta into the current error; nearer errors win on conflicts.\n      const merged: Record<string, unknown> = {}\n      for (const value of [...values].reverse()) {\n        Object.assign(merged, value)\n      }\n      return merged\n    },\n    serialize: ({ resolved, isPublic }) => {\n      if (hideWhenPublic && isPublic) {\n        return undefined\n      }\n      return toJsonSafe(resolved)\n    },\n    deserialize: ({ value }) => {\n      if (!isMetaRecord(value)) {\n        return undefined\n      }\n      return value\n    },\n  })\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,eAAuB;AAIvB,MAAM,aAAa,CAAC,UAAqC;AACvD,MAAI,UAAU,MAAM;AAClB,WAAO;AAAA,EACT;AACA,MAAI,OAAO,UAAU,YAAY,OAAO,UAAU,YAAY,OAAO,UAAU,WAAW;AACxF,WAAO;AAAA,EACT;AACA,MAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,WAAO,MAAM,IAAI,CAAC,UAAU,WAAW,KAAK,CAAC;AAAA,EAC/C;AACA,MAAI,OAAO,UAAU,UAAU;AAC7B,UAAM,SAA+B,CAAC;AACtC,eAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,KAAgC,GAAG;AAC3E,YAAM,YAAY,WAAW,KAAK;AAClC,UAAI,cAAc,QAAW;AAC3B,eAAO,GAAG,IAAI;AAAA,MAChB;AAAA,IACF;AACA,WAAO;AAAA,EACT;AACA,SAAO;AACT;AAEA,MAAM,eAAe,CAAC,UACpB,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK;AAE9D,MAAM,aAAa,CAAC,EAAE,iBAAiB,KAAK,IAAkC,CAAC,MACpF,gBAAO,OAAO,EAAE,KAAK,QAAQ;AAAA,EAC3B,MAAM,CAAC,UAAmC;AAAA,EAC1C,SAAS,CAAC,EAAE,KAAK,MAAM;AACrB,UAAM,SAAS,KAAK,OAAO,YAAY;AACvC,QAAI,OAAO,WAAW,GAAG;AACvB,aAAO;AAAA,IACT;AAGA,UAAM,SAAkC,CAAC;AACzC,eAAW,SAAS,CAAC,GAAG,MAAM,EAAE,QAAQ,GAAG;AACzC,aAAO,OAAO,QAAQ,KAAK;AAAA,IAC7B;AACA,WAAO;AAAA,EACT;AAAA,EACA,WAAW,CAAC,EAAE,UAAU,SAAS,MAAM;AACrC,QAAI,kBAAkB,UAAU;AAC9B,aAAO;AAAA,IACT;AACA,WAAO,WAAW,QAAQ;AAAA,EAC5B;AAAA,EACA,aAAa,CAAC,EAAE,MAAM,MAAM;AAC1B,QAAI,CAAC,aAAa,KAAK,GAAG;AACxB,aAAO;AAAA,IACT;AACA,WAAO;AAAA,EACT;AACF,CAAC;","names":[]}

package/dist/cjs/plugins/meta.d.cts

@@ -0,0 +1,7 @@
+import { PluginError0, ErrorPluginPropOptions, Error0 } from '../index.cjs';
+
+declare const metaPlugin: ({ hideWhenPublic }?: {
+    hideWhenPublic?: boolean;
+}) => PluginError0<Record<never, never> & Record<"meta", ErrorPluginPropOptions<Record<string, unknown>, Record<string, unknown>, Error0, Record<string, unknown> | undefined>>, Record<never, never>>;
+
+export { metaPlugin };

package/dist/cjs/plugins/stack-merge.cjs

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stack_merge_exports = {};
+__export(stack_merge_exports, {
+  stackMergePlugin: () => stackMergePlugin
+});
+module.exports = __toCommonJS(stack_merge_exports);
+var import__ = require('../index.cjs');
+const stackMergePlugin = ({
+  hideWhenPublic = true,
+  delimiter = "\n"
+} = {}) => import__.Error0.plugin().stack({
+  serialize: ({ error, isPublic }) => {
+    if (hideWhenPublic && isPublic) {
+      return void 0;
+    }
+    return error.causes().map((cause) => {
+      return cause instanceof Error ? cause.stack : void 0;
+    }).filter((value) => typeof value === "string").join(delimiter);
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  stackMergePlugin
+});
+//# sourceMappingURL=stack-merge.cjs.map

package/dist/cjs/plugins/stack-merge.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/plugins/stack-merge.ts"],"sourcesContent":["import { Error0 } from '../index.js'\n\nexport const stackMergePlugin = ({\n  hideWhenPublic = true,\n  delimiter = '\\n',\n}: { hideWhenPublic?: boolean; delimiter?: string } = {}) =>\n  Error0.plugin().stack({\n    serialize: ({ error, isPublic }) => {\n      if (hideWhenPublic && isPublic) {\n        return undefined\n      }\n      return error\n        .causes()\n        .map((cause) => {\n          return cause instanceof Error ? cause.stack : undefined\n        })\n        .filter((value): value is string => typeof value === 'string')\n        .join(delimiter)\n    },\n  })\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,eAAuB;AAEhB,MAAM,mBAAmB,CAAC;AAAA,EAC/B,iBAAiB;AAAA,EACjB,YAAY;AACd,IAAsD,CAAC,MACrD,gBAAO,OAAO,EAAE,MAAM;AAAA,EACpB,WAAW,CAAC,EAAE,OAAO,SAAS,MAAM;AAClC,QAAI,kBAAkB,UAAU;AAC9B,aAAO;AAAA,IACT;AACA,WAAO,MACJ,OAAO,EACP,IAAI,CAAC,UAAU;AACd,aAAO,iBAAiB,QAAQ,MAAM,QAAQ;AAAA,IAChD,CAAC,EACA,OAAO,CAAC,UAA2B,OAAO,UAAU,QAAQ,EAC5D,KAAK,SAAS;AAAA,EACnB;AACF,CAAC;","names":[]}

package/dist/cjs/plugins/stack-merge.d.cts

@@ -0,0 +1,8 @@
+import { PluginError0 } from '../index.cjs';
+
+declare const stackMergePlugin: ({ hideWhenPublic, delimiter, }?: {
+    hideWhenPublic?: boolean;
+    delimiter?: string;
+}) => PluginError0<Record<never, never>, Record<never, never>>;
+
+export { stackMergePlugin };

package/dist/cjs/plugins/status.cjs

@@ -0,0 +1,54 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var status_exports = {};
+__export(status_exports, {
+  statusPlugin: () => statusPlugin
+});
+module.exports = __toCommonJS(status_exports);
+var import__ = require('../index.cjs');
+const statusPlugin = ({
+  statuses,
+  strict = false
+} = {}) => {
+  const statusValues = statuses ? Object.values(statuses) : void 0;
+  const isStatusValue = (value) => typeof value === "number" && (!statusValues || !strict || statusValues.includes(value));
+  const normalizeStatusValue = (value) => {
+    return isStatusValue(value) ? value : void 0;
+  };
+  const convertStatusValue = (value) => {
+    if (typeof value === "number") {
+      return normalizeStatusValue(value);
+    }
+    if (statuses && value in statuses) {
+      return statuses[value];
+    }
+    return void 0;
+  };
+  return import__.Error0.plugin().prop("status", {
+    init: (status) => convertStatusValue(status),
+    resolve: ({ flow }) => flow.find(Boolean),
+    serialize: ({ resolved }) => resolved,
+    deserialize: ({ value }) => typeof value === "number" ? value : void 0
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  statusPlugin
+});
+//# sourceMappingURL=status.cjs.map

package/dist/cjs/plugins/status.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/plugins/status.ts"],"sourcesContent":["import { Error0 } from '../index.js'\n\nexport const statusPlugin = <TStatuses extends Record<string, number> = Record<never, number>>({\n  statuses,\n  strict = false,\n}: { statuses?: TStatuses; strict?: boolean } = {}) => {\n  const statusValues = statuses ? Object.values(statuses) : undefined\n  const isStatusValue = (value: unknown): value is number =>\n    typeof value === 'number' && (!statusValues || !strict || statusValues.includes(value))\n  const normalizeStatusValue = (value: unknown): number | undefined => {\n    return isStatusValue(value) ? value : undefined\n  }\n  const convertStatusValue = (value: number | string): number | undefined => {\n    if (typeof value === 'number') {\n      return normalizeStatusValue(value)\n    }\n    if (statuses && value in statuses) {\n      return statuses[value as keyof TStatuses]\n    }\n    return undefined\n  }\n\n  return Error0.plugin().prop('status', {\n    init: (status: number | Extract<keyof TStatuses, string>) => convertStatusValue(status),\n    resolve: ({ flow }) => flow.find(Boolean),\n    serialize: ({ resolved }) => resolved,\n    deserialize: ({ value }) => (typeof value === 'number' ? value : undefined),\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,eAAuB;AAEhB,MAAM,eAAe,CAAmE;AAAA,EAC7F;AAAA,EACA,SAAS;AACX,IAAgD,CAAC,MAAM;AACrD,QAAM,eAAe,WAAW,OAAO,OAAO,QAAQ,IAAI;AAC1D,QAAM,gBAAgB,CAAC,UACrB,OAAO,UAAU,aAAa,CAAC,gBAAgB,CAAC,UAAU,aAAa,SAAS,KAAK;AACvF,QAAM,uBAAuB,CAAC,UAAuC;AACnE,WAAO,cAAc,KAAK,IAAI,QAAQ;AAAA,EACxC;AACA,QAAM,qBAAqB,CAAC,UAA+C;AACzE,QAAI,OAAO,UAAU,UAAU;AAC7B,aAAO,qBAAqB,KAAK;AAAA,IACnC;AACA,QAAI,YAAY,SAAS,UAAU;AACjC,aAAO,SAAS,KAAwB;AAAA,IAC1C;AACA,WAAO;AAAA,EACT;AAEA,SAAO,gBAAO,OAAO,EAAE,KAAK,UAAU;AAAA,IACpC,MAAM,CAAC,WAAsD,mBAAmB,MAAM;AAAA,IACtF,SAAS,CAAC,EAAE,KAAK,MAAM,KAAK,KAAK,OAAO;AAAA,IACxC,WAAW,CAAC,EAAE,SAAS,MAAM;AAAA,IAC7B,aAAa,CAAC,EAAE,MAAM,MAAO,OAAO,UAAU,WAAW,QAAQ;AAAA,EACnE,CAAC;AACH;","names":[]}

package/dist/cjs/plugins/status.d.cts

@@ -0,0 +1,8 @@
+import { PluginError0, ErrorPluginPropOptions, Error0 } from '../index.cjs';
+
+declare const statusPlugin: <TStatuses extends Record<string, number> = Record<never, number>>({ statuses, strict, }?: {
+    statuses?: TStatuses;
+    strict?: boolean;
+}) => PluginError0<Record<never, never> & Record<"status", ErrorPluginPropOptions<number | Extract<keyof TStatuses, string>, number | undefined, Error0, number | undefined>>, Record<never, never>>;
+
+export { statusPlugin };

package/dist/cjs/plugins/tags.cjs

@@ -0,0 +1,73 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tags_exports = {};
+__export(tags_exports, {
+  tagsPlugin: () => tagsPlugin
+});
+module.exports = __toCommonJS(tags_exports);
+var import__ = require('../index.cjs');
+const tagsPlugin = ({
+  hideWhenPublic = true,
+  tags,
+  strict = true
+} = {}) => {
+  function hasTag(error, tag, policy) {
+    const tags2 = error.tags;
+    if (!tags2) {
+      return false;
+    }
+    if (Array.isArray(tag)) {
+      if (policy === "every") {
+        return tag.every((item) => tags2.includes(item));
+      }
+      return tag.some((item) => tags2.includes(item));
+    }
+    return tags2.includes(tag);
+  }
+  const isTag = (value) => typeof value === "string" && (!tags || !strict || tags.includes(value));
+  return import__.Error0.plugin().prop("tags", {
+    init: (input) => input,
+    resolve: ({ flow }) => {
+      const merged = [];
+      for (const value of flow) {
+        if (Array.isArray(value)) {
+          merged.push(...value);
+        }
+      }
+      return merged.length > 0 ? Array.from(new Set(merged)) : void 0;
+    },
+    serialize: ({ resolved, isPublic }) => {
+      if (hideWhenPublic && isPublic) {
+        return void 0;
+      }
+      return resolved;
+    },
+    deserialize: ({ value }) => {
+      if (!Array.isArray(value)) {
+        return void 0;
+      }
+      return value.filter((item) => isTag(item));
+    }
+  }).method("hasTag", hasTag);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  tagsPlugin
+});
+//# sourceMappingURL=tags.cjs.map

package/dist/cjs/plugins/tags.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/plugins/tags.ts"],"sourcesContent":["import { Error0 } from '../index.js'\n\nexport const tagsPlugin = <TTag extends string>({\n  hideWhenPublic = true,\n  tags,\n  strict = true,\n}: { hideWhenPublic?: boolean; tags?: TTag[] | readonly TTag[]; strict?: boolean } = {}) => {\n  function hasTag(error: Error0, tag: TTag): boolean\n  function hasTag(error: Error0, tag: TTag[], policy: 'every' | 'some'): boolean\n  function hasTag(error: Error0, tag: TTag | TTag[], policy?: 'every' | 'some'): boolean {\n    const tags = (error as any).tags as string[] | undefined\n    if (!tags) {\n      return false\n    }\n    if (Array.isArray(tag)) {\n      if (policy === 'every') {\n        return tag.every((item) => tags.includes(item))\n      }\n      return tag.some((item) => tags.includes(item))\n    }\n    return tags.includes(tag)\n  }\n  const isTag = (value: unknown): value is TTag =>\n    typeof value === 'string' && (!tags || !strict || tags.includes(value as TTag))\n  return Error0.plugin()\n    .prop('tags', {\n      init: (input: string[]) => input,\n      resolve: ({ flow }) => {\n        const merged: string[] = []\n        for (const value of flow) {\n          if (Array.isArray(value)) {\n            merged.push(...value)\n          }\n        }\n        return merged.length > 0 ? Array.from(new Set(merged)) : undefined\n      },\n      serialize: ({ resolved, isPublic }) => {\n        if (hideWhenPublic && isPublic) {\n          return undefined\n        }\n        return resolved\n      },\n      deserialize: ({ value }) => {\n        if (!Array.isArray(value)) {\n          return undefined\n        }\n        return value.filter((item) => isTag(item))\n      },\n    })\n    .method('hasTag', hasTag)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,eAAuB;AAEhB,MAAM,aAAa,CAAsB;AAAA,EAC9C,iBAAiB;AAAA,EACjB;AAAA,EACA,SAAS;AACX,IAAqF,CAAC,MAAM;AAG1F,WAAS,OAAO,OAAe,KAAoB,QAAoC;AACrF,UAAMA,QAAQ,MAAc;AAC5B,QAAI,CAACA,OAAM;AACT,aAAO;AAAA,IACT;AACA,QAAI,MAAM,QAAQ,GAAG,GAAG;AACtB,UAAI,WAAW,SAAS;AACtB,eAAO,IAAI,MAAM,CAAC,SAASA,MAAK,SAAS,IAAI,CAAC;AAAA,MAChD;AACA,aAAO,IAAI,KAAK,CAAC,SAASA,MAAK,SAAS,IAAI,CAAC;AAAA,IAC/C;AACA,WAAOA,MAAK,SAAS,GAAG;AAAA,EAC1B;AACA,QAAM,QAAQ,CAAC,UACb,OAAO,UAAU,aAAa,CAAC,QAAQ,CAAC,UAAU,KAAK,SAAS,KAAa;AAC/E,SAAO,gBAAO,OAAO,EAClB,KAAK,QAAQ;AAAA,IACZ,MAAM,CAAC,UAAoB;AAAA,IAC3B,SAAS,CAAC,EAAE,KAAK,MAAM;AACrB,YAAM,SAAmB,CAAC;AAC1B,iBAAW,SAAS,MAAM;AACxB,YAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,iBAAO,KAAK,GAAG,KAAK;AAAA,QACtB;AAAA,MACF;AACA,aAAO,OAAO,SAAS,IAAI,MAAM,KAAK,IAAI,IAAI,MAAM,CAAC,IAAI;AAAA,IAC3D;AAAA,IACA,WAAW,CAAC,EAAE,UAAU,SAAS,MAAM;AACrC,UAAI,kBAAkB,UAAU;AAC9B,eAAO;AAAA,MACT;AACA,aAAO;AAAA,IACT;AAAA,IACA,aAAa,CAAC,EAAE,MAAM,MAAM;AAC1B,UAAI,CAAC,MAAM,QAAQ,KAAK,GAAG;AACzB,eAAO;AAAA,MACT;AACA,aAAO,MAAM,OAAO,CAAC,SAAS,MAAM,IAAI,CAAC;AAAA,IAC3C;AAAA,EACF,CAAC,EACA,OAAO,UAAU,MAAM;AAC5B;","names":["tags"]}

package/dist/cjs/plugins/tags.d.cts

@@ -0,0 +1,12 @@
+import { PluginError0, ErrorPluginPropOptions, Error0 } from '../index.cjs';
+
+declare const tagsPlugin: <TTag extends string>({ hideWhenPublic, tags, strict, }?: {
+    hideWhenPublic?: boolean;
+    tags?: TTag[] | readonly TTag[];
+    strict?: boolean;
+}) => PluginError0<Record<never, never> & Record<"tags", ErrorPluginPropOptions<string[], string[], Error0, string[] | undefined>>, Record<never, never> & Record<"hasTag", {
+    (error: Error0, tag: TTag): boolean;
+    (error: Error0, tag: TTag[], policy: "every" | "some"): boolean;
+}>>;
+
+export { tagsPlugin };