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

package/dist/cjs/index.cjs

@@ -0,0 +1,614 @@
+"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 index_exports = {};
+__export(index_exports, {
+  Error0: () => Error0,
+  PluginError0: () => PluginError0
+});
+module.exports = __toCommonJS(index_exports);
+const RESERVED_STACK_PROP_ERROR = 'Error0: "stack" is a reserved prop key. Use .stack(...) plugin API instead';
+const RESERVED_MESSAGE_PROP_ERROR = 'Error0: "message" is a reserved prop key. Use .message(...) plugin API instead';
+class PluginError0 {
+  _plugin;
+  Infer = void 0;
+  constructor(plugin) {
+    this._plugin = {
+      props: { ...plugin?.props ?? {} },
+      methods: { ...plugin?.methods ?? {} },
+      adapt: [...plugin?.adapt ?? []],
+      stack: plugin?.stack,
+      cause: plugin?.cause,
+      message: plugin?.message
+    };
+  }
+  prop(key, value) {
+    return this.use("prop", key, value);
+  }
+  method(key, value) {
+    return this.use("method", key, value);
+  }
+  adapt(value) {
+    return this.use("adapt", value);
+  }
+  stack(value) {
+    return this.use("stack", value);
+  }
+  cause(value) {
+    return this.use("cause", value);
+  }
+  message(value) {
+    return this.use("message", value);
+  }
+  use(kind, keyOrValue, value) {
+    const nextProps = { ...this._plugin.props ?? {} };
+    const nextMethods = { ...this._plugin.methods ?? {} };
+    const nextAdapt = [...this._plugin.adapt ?? []];
+    let nextStack = this._plugin.stack;
+    let nextCause = this._plugin.cause;
+    let nextMessage = this._plugin.message;
+    if (kind === "prop") {
+      const key = keyOrValue;
+      if (key === "stack") {
+        throw new Error(RESERVED_STACK_PROP_ERROR);
+      }
+      if (key === "message") {
+        throw new Error(RESERVED_MESSAGE_PROP_ERROR);
+      }
+      if (value === void 0) {
+        throw new Error('PluginError0.use("prop", key, value) requires value');
+      }
+      nextProps[key] = value;
+    } else if (kind === "method") {
+      const key = keyOrValue;
+      if (value === void 0) {
+        throw new Error('PluginError0.use("method", key, value) requires value');
+      }
+      nextMethods[key] = value;
+    } else if (kind === "adapt") {
+      nextAdapt.push(keyOrValue);
+    } else if (kind === "stack") {
+      nextStack = keyOrValue;
+    } else if (kind === "cause") {
+      nextCause = keyOrValue;
+    } else {
+      nextMessage = keyOrValue;
+    }
+    return new PluginError0({
+      props: nextProps,
+      methods: nextMethods,
+      adapt: nextAdapt,
+      stack: nextStack,
+      cause: nextCause,
+      message: nextMessage
+    });
+  }
+}
+const OWN_SYMBOL = Symbol("Error0.own");
+class Error0 extends Error {
+  static __pluginsMap;
+  __pluginsMap;
+  static MAX_CAUSES_DEPTH = 99;
+  static _plugins = [];
+  static _resolvedPlugin;
+  static _emptyPlugin = {
+    props: {},
+    methods: {},
+    adapt: [],
+    stack: void 0,
+    cause: void 0,
+    message: void 0,
+    propKeys: [],
+    propEntries: [],
+    methodEntries: []
+  };
+  static _indexResolvedPlugin(resolved) {
+    return {
+      ...resolved,
+      propKeys: Object.keys(resolved.props),
+      propEntries: Object.entries(resolved.props),
+      methodEntries: Object.entries(resolved.methods)
+    };
+  }
+  static _applyPlugin(resolved, plugin) {
+    if (plugin.props && "stack" in plugin.props) {
+      throw new Error(RESERVED_STACK_PROP_ERROR);
+    }
+    if (plugin.props && "message" in plugin.props) {
+      throw new Error(RESERVED_MESSAGE_PROP_ERROR);
+    }
+    Object.assign(resolved.props, plugin.props ?? this._emptyPlugin.props);
+    Object.assign(resolved.methods, plugin.methods ?? this._emptyPlugin.methods);
+    resolved.adapt.push(...plugin.adapt ?? this._emptyPlugin.adapt);
+    if (typeof plugin.stack !== "undefined") {
+      resolved.stack = plugin.stack;
+    }
+    if (typeof plugin.cause !== "undefined") {
+      resolved.cause = plugin.cause;
+    }
+    if (typeof plugin.message !== "undefined") {
+      resolved.message = plugin.message;
+    }
+  }
+  static _mergeResolvedPlugin(base, plugin) {
+    const merged = {
+      props: { ...base.props },
+      methods: { ...base.methods },
+      adapt: [...base.adapt],
+      stack: base.stack,
+      cause: base.cause,
+      message: base.message
+    };
+    this._applyPlugin(merged, plugin);
+    return this._indexResolvedPlugin(merged);
+  }
+  static _getResolvedPlugin() {
+    if (Object.prototype.hasOwnProperty.call(this, "_resolvedPlugin") && this._resolvedPlugin) {
+      return this._resolvedPlugin;
+    }
+    const resolved = {
+      props: {},
+      methods: {},
+      adapt: [],
+      propKeys: [],
+      propEntries: [],
+      methodEntries: []
+    };
+    for (const plugin of this._plugins) {
+      this._applyPlugin(resolved, plugin);
+    }
+    const indexed = this._indexResolvedPlugin(resolved);
+    Object.defineProperty(this, "_resolvedPlugin", {
+      value: indexed,
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+    return indexed;
+  }
+  constructor(...args) {
+    const [first, second] = args;
+    const input = typeof first === "string" ? { message: first, ...second ?? {} } : first;
+    super(input.message, { cause: input.cause });
+    this.name = "Error0";
+    const ctor = this.constructor;
+    const plugin = ctor._getResolvedPlugin();
+    const ownStore = /* @__PURE__ */ Object.create(null);
+    Object.defineProperty(this, OWN_SYMBOL, { value: ownStore, writable: true, enumerable: false, configurable: true });
+    for (const [key, prop] of plugin.propEntries) {
+      if (key === "stack") {
+        continue;
+      }
+      Object.defineProperty(this, key, {
+        get: () => prop.resolve({
+          own: ownStore[key],
+          flow: this.flow(key),
+          error: this
+        }),
+        set: (value) => {
+          ownStore[key] = value;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      if (key in input) {
+        const ownValue = input[key];
+        ownStore[key] = typeof prop.init === "function" ? prop.init(ownValue) : ownValue;
+      }
+    }
+  }
+  static _getOwnStore(object) {
+    const record = object;
+    const existing = record[OWN_SYMBOL];
+    if (existing && typeof existing === "object") {
+      return existing;
+    }
+    return void 0;
+  }
+  static isOwnProperty = (object, key) => {
+    const ownStore = this._getOwnStore(object);
+    if (ownStore) {
+      return Object.prototype.hasOwnProperty.call(ownStore, key);
+    }
+    return !!Object.getOwnPropertyDescriptor(object, key);
+  };
+  static _ownByKey(error, key) {
+    const ownStore = this._getOwnStore(error);
+    if (ownStore) {
+      return ownStore[key];
+    }
+    return error[key];
+  }
+  static _flowByKey(error, key) {
+    const causes = this.causes(error, true);
+    const values = new Array(causes.length);
+    for (let i = 0; i < causes.length; i += 1) {
+      values[i] = this._ownByKey(causes[i], key);
+    }
+    return values;
+  }
+  static own(error, key) {
+    const error0 = this.from(error);
+    if (key === void 0) {
+      const ownValues = {};
+      const plugin = this._getResolvedPlugin();
+      for (const ownKey of plugin.propKeys) {
+        ownValues[ownKey] = this._ownByKey(error0, ownKey);
+      }
+      return ownValues;
+    }
+    return this._ownByKey(error0, key);
+  }
+  own(key) {
+    const ctor = this.constructor;
+    if (key === void 0) {
+      return ctor.own(this);
+    }
+    return ctor._ownByKey(this, key);
+  }
+  static flow(error, key) {
+    const error0 = this.from(error);
+    return this._flowByKey(error0, key);
+  }
+  flow(key) {
+    const ctor = this.constructor;
+    return ctor._flowByKey(this, key);
+  }
+  static _resolveByKey(error, key, plugin) {
+    try {
+      const options = {
+        get own() {
+          return error.own(key);
+        },
+        get flow() {
+          return error.flow(key);
+        },
+        error
+      };
+      const prop = plugin.props[key];
+      const resolver = prop.resolve;
+      if (!resolver) {
+        return error[key];
+      }
+      return resolver(options);
+    } catch {
+      console.error(`Error0: failed to resolve property ${key}`, error);
+      return void 0;
+    }
+  }
+  static resolve(error) {
+    const error0 = this.from(error);
+    const resolved = {};
+    const plugin = this._getResolvedPlugin();
+    for (const key of plugin.propKeys) {
+      resolved[key] = this._resolveByKey(error0, key, plugin);
+    }
+    return resolved;
+  }
+  resolve() {
+    const ctor = this.constructor;
+    return ctor.resolve(this);
+  }
+  static causes(error, instancesOnly) {
+    const causes = [];
+    let current = error;
+    const seen = /* @__PURE__ */ new Set();
+    let depth = 0;
+    while (depth < this.MAX_CAUSES_DEPTH) {
+      if (seen.has(current)) {
+        break;
+      }
+      seen.add(current);
+      if (!instancesOnly || this.is(current)) {
+        causes.push(current);
+      }
+      if (!current || typeof current !== "object") {
+        break;
+      }
+      current = current.cause;
+      depth += 1;
+    }
+    return causes;
+  }
+  causes(instancesOnly) {
+    const ctor = this.constructor;
+    if (instancesOnly) {
+      return ctor.causes(this, true);
+    }
+    return ctor.causes(this);
+  }
+  static is(error) {
+    return error instanceof this;
+  }
+  static isSerialized(error) {
+    return !this.is(error) && typeof error === "object" && error !== null && "name" in error && error.name === "Error0";
+  }
+  static from(error) {
+    if (this.is(error)) {
+      return error;
+    }
+    if (this.isSerialized(error)) {
+      return this._fromSerialized(error);
+    }
+    return this._fromNonError0(error);
+  }
+  static round(error, isPublic = false) {
+    return this.from(this.serialize(error, isPublic));
+  }
+  static _applyAdapt(error) {
+    const plugin = this._getResolvedPlugin();
+    for (const adapt of plugin.adapt) {
+      const adapted = adapt(error);
+      if (adapted && typeof adapted === "object") {
+        Object.assign(error, adapted);
+      }
+    }
+    return error;
+  }
+  static _fromSerialized(error) {
+    const message = this._extractMessage(error);
+    if (typeof error !== "object" || error === null) {
+      return this._applyAdapt(new this(message, { cause: error }));
+    }
+    const errorRecord = error;
+    const recreated = new this(message);
+    const plugin = this._getResolvedPlugin();
+    for (const [key, prop] of plugin.propEntries) {
+      if (prop.deserialize === false) {
+        continue;
+      }
+      if (!(key in errorRecord)) {
+        continue;
+      }
+      try {
+        const value = prop.deserialize({ value: errorRecord[key], record: errorRecord });
+        recreated[key] = value;
+      } catch {
+        console.error(`Error0: failed to deserialize property ${key}`, errorRecord);
+      }
+    }
+    if ("stack" in errorRecord) {
+      try {
+        if (typeof errorRecord.stack === "string") {
+          recreated.stack = errorRecord.stack;
+        }
+      } catch {
+        console.error("Error0: failed to deserialize stack", errorRecord);
+      }
+    }
+    const causePlugin = plugin.cause;
+    if (causePlugin && "cause" in errorRecord) {
+      try {
+        ;
+        recreated.cause = causePlugin.deserialize({
+          cause: errorRecord.cause,
+          error: errorRecord,
+          isSerialized: (serializedCause) => this.isSerialized(serializedCause),
+          fromSerialized: (serializedCause) => this._fromSerialized(serializedCause)
+        });
+      } catch {
+        console.error("Error0: failed to deserialize cause", errorRecord);
+      }
+    }
+    return recreated;
+  }
+  static _fromNonError0(error) {
+    const message = this._extractMessage(error);
+    return this._applyAdapt(new this(message, { cause: error }));
+  }
+  static _extractMessage(error) {
+    return (typeof error === "string" ? error : typeof error === "object" && error !== null && "message" in error && typeof error.message === "string" ? error.message : void 0) || "Unknown error";
+  }
+  static _useWithPlugin(plugin) {
+    const Base = this;
+    const Error0Extended = class Error0 extends Base {
+    };
+    Error0Extended._plugins = [...Base._plugins, plugin];
+    const resolved = this._mergeResolvedPlugin(Base._getResolvedPlugin(), plugin);
+    Error0Extended._resolvedPlugin = resolved;
+    for (const [key, method] of resolved.methodEntries) {
+      Object.defineProperty(Error0Extended.prototype, key, {
+        value: function(...args) {
+          return method(this, ...args);
+        },
+        writable: true,
+        enumerable: true,
+        configurable: true
+      });
+      Object.defineProperty(Error0Extended, key, {
+        value: function(error, ...args) {
+          return method(this.from(error), ...args);
+        },
+        writable: true,
+        enumerable: true,
+        configurable: true
+      });
+    }
+    return Error0Extended;
+  }
+  static _pluginFromBuilder(plugin) {
+    const pluginRecord = plugin;
+    return {
+      props: { ...pluginRecord._plugin.props ?? {} },
+      methods: { ...pluginRecord._plugin.methods ?? {} },
+      adapt: [...pluginRecord._plugin.adapt ?? []],
+      stack: pluginRecord._plugin.stack,
+      cause: pluginRecord._plugin.cause,
+      message: pluginRecord._plugin.message
+    };
+  }
+  static use(first, key, value) {
+    if (first instanceof PluginError0) {
+      return this._useWithPlugin(this._pluginFromBuilder(first));
+    }
+    if (first === "stack") {
+      if (typeof key === "undefined") {
+        throw new Error('Error0.use("stack", value) requires stack plugin value');
+      }
+      if (typeof key !== "object" || key === null || typeof key.serialize !== "function") {
+        throw new Error('Error0.use("stack", value) expects { serialize: function }');
+      }
+      return this._useWithPlugin({
+        stack: key
+      });
+    }
+    if (first === "cause") {
+      if (typeof key === "undefined") {
+        throw new Error('Error0.use("cause", value) requires cause plugin value');
+      }
+      if (typeof key !== "object" || key === null || typeof key.serialize !== "function" || typeof key.deserialize !== "function") {
+        throw new Error('Error0.use("cause", value) expects { serialize: function, deserialize: function }');
+      }
+      return this._useWithPlugin({
+        cause: key
+      });
+    }
+    if (first === "message") {
+      if (typeof key === "undefined") {
+        throw new Error('Error0.use("message", value) requires message plugin value');
+      }
+      if (typeof key !== "object" || key === null || typeof key.serialize !== "function") {
+        throw new Error('Error0.use("message", value) expects { serialize: function }');
+      }
+      return this._useWithPlugin({
+        message: key
+      });
+    }
+    if (first === "adapt") {
+      if (typeof key !== "function") {
+        throw new Error('Error0.use("adapt", value) requires adapt function');
+      }
+      return this._useWithPlugin({
+        adapt: [key]
+      });
+    }
+    if (typeof key !== "string" || value === void 0) {
+      throw new Error("Error0.use(kind, key, value) requires key and value");
+    }
+    if (first === "prop") {
+      if (key === "stack") {
+        throw new Error(RESERVED_STACK_PROP_ERROR);
+      }
+      if (key === "message") {
+        throw new Error(RESERVED_MESSAGE_PROP_ERROR);
+      }
+      return this._useWithPlugin({
+        props: { [key]: value }
+      });
+    }
+    return this._useWithPlugin({
+      methods: { [key]: value }
+    });
+  }
+  static plugin() {
+    return new PluginError0();
+  }
+  static serialize(error, isPublic = true) {
+    const error0 = this.from(error);
+    const plugin = this._getResolvedPlugin();
+    const resolveByKey = (targetError, key, targetPlugin) => this._resolveByKey(targetError, key, targetPlugin);
+    const messagePlugin = plugin.message;
+    let serializedMessage = error0.message;
+    try {
+      if (messagePlugin) {
+        serializedMessage = messagePlugin.serialize({ value: error0.message, error: error0, isPublic });
+      }
+    } catch {
+      console.error("Error0: failed to serialize message", error0);
+      serializedMessage = error0.message;
+    }
+    const json = {
+      name: error0.name
+    };
+    if (serializedMessage !== void 0) {
+      json.message = serializedMessage;
+    }
+    for (const [key, prop] of plugin.propEntries) {
+      if (prop.serialize === false) {
+        continue;
+      }
+      try {
+        const options = {
+          get own() {
+            return error0.own(key);
+          },
+          get flow() {
+            return error0.flow(key);
+          },
+          get resolved() {
+            return resolveByKey(error0, key, plugin);
+          },
+          error: error0,
+          isPublic
+        };
+        const jsonValue = prop.serialize(options);
+        if (jsonValue !== void 0) {
+          json[key] = jsonValue;
+        }
+      } catch {
+        console.error(`Error0: failed to serialize property ${key}`, error0);
+      }
+    }
+    const stackPlugin = plugin.stack;
+    try {
+      let serializedStack;
+      if (stackPlugin) {
+        serializedStack = stackPlugin.serialize({ value: error0.stack, error: error0, isPublic });
+      } else {
+        serializedStack = isPublic ? void 0 : error0.stack;
+      }
+      if (serializedStack !== void 0) {
+        json.stack = serializedStack;
+      }
+    } catch {
+      console.error("Error0: failed to serialize stack", error0);
+    }
+    const causePlugin = plugin.cause;
+    if (causePlugin?.serialize) {
+      try {
+        const serializedCause = causePlugin.serialize({
+          cause: error0.cause,
+          error: error0,
+          isPublic,
+          is: (cause) => this.is(cause),
+          serialize: (cause) => this.serialize(cause, isPublic)
+        });
+        if (serializedCause !== void 0) {
+          json.cause = serializedCause;
+        }
+      } catch {
+        console.error("Error0: failed to serialize cause", error0);
+      }
+    }
+    return json;
+  }
+  serialize(isPublic = true) {
+    const ctor = this.constructor;
+    return ctor.serialize(this, isPublic);
+  }
+  round(isPublic = true) {
+    const ctor = this.constructor;
+    return ctor.round(this, isPublic);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Error0,
+  PluginError0
+});
+//# sourceMappingURL=index.cjs.map