@devp0nt/error0 1.0.0-next.47 → 1.0.0-next.49

package/dist/cjs/index.cjs

@@ -99,45 +99,87 @@ class PluginError0 {
     });
   }
 }
+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
+    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: []
+      adapt: [],
+      propKeys: [],
+      propEntries: [],
+      methodEntries: []
     };
     for (const plugin of this._plugins) {
-      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;
-      }
+      this._applyPlugin(resolved, plugin);
     }
-    return resolved;
+    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;
@@ -146,37 +188,43 @@ class Error0 extends Error {
     this.name = "Error0";
     const ctor = this.constructor;
     const plugin = ctor._getResolvedPlugin();
-    for (const [key, prop] of Object.entries(plugin.props)) {
+    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];
-        if (typeof prop.init === "function") {
-          ;
-          this[key] = prop.init(ownValue);
-        } else {
-          ;
-          this[key] = ownValue;
-        }
-      } else {
-        Object.defineProperty(this, key, {
-          get: () => prop.resolve({ own: void 0, flow: this.flow(key), error: this }),
-          set: (value) => {
-            Object.defineProperty(this, key, {
-              value,
-              writable: true,
-              enumerable: true,
-              configurable: true
-            });
-          },
-          enumerable: true,
-          configurable: true
-        });
+        ownStore[key] = typeof prop.init === "function" ? prop.init(ownValue) : ownValue;
       }
     }
   }
-  static isSelfProperty = (object, key) => {
+  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 && Object.prototype.hasOwnProperty.call(ownStore, key)) {
+      return true;
+    }
     const d = Object.getOwnPropertyDescriptor(object, key);
     if (!d) return false;
     if (typeof d.get === "function" || typeof d.set === "function") {
@@ -189,22 +237,29 @@ class Error0 extends Error {
     return true;
   };
   static _ownByKey(error, key) {
-    if (this.isSelfProperty(error, key)) {
+    const ownStore = this._getOwnStore(error);
+    if (ownStore && Object.prototype.hasOwnProperty.call(ownStore, key)) {
+      return ownStore[key];
+    }
+    if (this.isOwnProperty(error, key)) {
       return error[key];
     }
     return void 0;
   }
   static _flowByKey(error, key) {
-    return this.causes(error, true).map((cause) => {
-      return this._ownByKey(cause, 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 Object.keys(plugin.props)) {
+      for (const ownKey of plugin.propKeys) {
         ownValues[ownKey] = this._ownByKey(error0, ownKey);
       }
       return ownValues;
@@ -226,29 +281,34 @@ class Error0 extends Error {
     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, prop] of Object.entries(plugin.props)) {
-      try {
-        const options = Object.defineProperties(
-          {
-            error: error0
-          },
-          {
-            own: {
-              get: () => error0.own(key)
-            },
-            flow: {
-              get: () => error0.flow(key)
-            }
-          }
-        );
-        resolved[key] = prop.resolve(options);
-      } catch {
-        console.error(`Error0: failed to resolve property ${key}`, error0);
-      }
+    for (const key of plugin.propKeys) {
+      resolved[key] = this._resolveByKey(error0, key, plugin);
     }
     return resolved;
   }
@@ -259,9 +319,9 @@ class Error0 extends Error {
   static causes(error, instancesOnly) {
     const causes = [];
     let current = error;
-    const maxDepth = 99;
     const seen = /* @__PURE__ */ new Set();
-    for (let depth = 0; depth < maxDepth; depth += 1) {
+    let depth = 0;
+    while (depth < this.MAX_CAUSES_DEPTH) {
       if (seen.has(current)) {
         break;
       }
@@ -273,6 +333,7 @@ class Error0 extends Error {
         break;
       }
       current = current.cause;
+      depth += 1;
     }
     return causes;
   }
@@ -298,6 +359,9 @@ class Error0 extends 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) {
@@ -316,8 +380,7 @@ class Error0 extends Error {
     const errorRecord = error;
     const recreated = new this(message);
     const plugin = this._getResolvedPlugin();
-    const propsEntries = Object.entries(plugin.props);
-    for (const [key, prop] of propsEntries) {
+    for (const [key, prop] of plugin.propEntries) {
       if (prop.deserialize === false) {
         continue;
       }
@@ -325,7 +388,7 @@ class Error0 extends Error {
         continue;
       }
       try {
-        const value = prop.deserialize({ value: errorRecord[key], serialized: errorRecord });
+        const value = prop.deserialize({ value: errorRecord[key], record: errorRecord });
         recreated[key] = value;
       } catch {
         console.error(`Error0: failed to deserialize property ${key}`, errorRecord);
@@ -368,8 +431,9 @@ class Error0 extends Error {
     const Error0Extended = class Error0 extends Base {
     };
     Error0Extended._plugins = [...Base._plugins, plugin];
-    const resolved = Error0Extended._getResolvedPlugin();
-    for (const [key, method] of Object.entries(resolved.methods)) {
+    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);
@@ -468,9 +532,8 @@ class Error0 extends Error {
   }
   static serialize(error, isPublic = true) {
     const error0 = this.from(error);
-    const resolvedProps = this.resolve(error0);
-    const resolvedRecord = resolvedProps;
     const plugin = this._getResolvedPlugin();
+    const resolveByKey = (targetError, key, targetPlugin) => this._resolveByKey(targetError, key, targetPlugin);
     const messagePlugin = plugin.message;
     let serializedMessage = error0.message;
     try {
@@ -482,24 +545,37 @@ class Error0 extends Error {
       serializedMessage = error0.message;
     }
     const json = {
-      name: error0.name,
-      message: serializedMessage
+      name: error0.name
       // we do not serialize causes, it is enough that we have floated props and adapt helper
       // cause: error0.cause,
     };
-    const propsEntries = Object.entries(plugin.props);
-    for (const [key, prop] of propsEntries) {
+    if (serializedMessage !== void 0) {
+      json.message = serializedMessage;
+    }
+    for (const [key, prop] of plugin.propEntries) {
       if (prop.serialize === false) {
         continue;
       }
       try {
-        const value = resolvedRecord[key];
-        const jsonValue = prop.serialize({ value, error: error0, isPublic });
+        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}`, resolvedRecord);
+        console.error(`Error0: failed to serialize property ${key}`, error0);
       }
     }
     const stackPlugin = plugin.stack;
@@ -531,12 +607,16 @@ class Error0 extends Error {
         console.error("Error0: failed to serialize cause", error0);
       }
     }
-    return Object.fromEntries(Object.entries(json).filter(([, value]) => value !== void 0));
+    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 = {