adaptive-extender 0.10.5 → 0.11.1

package/dist/core/portable.js

@@ -9,28 +9,35 @@ import "./reflect.js";
 import "./error.js";
 import {} from "./global.js";
 //#endregion
-//#region Field descriptor
+//#region Descriptors
+Reflect.set(Symbol, "metadata", Reflect.get(Symbol, "metadata") ?? Symbol.for("Symbol.metadata"));
 class FieldDescriptor {
     #key;
     #association;
     #type;
-    constructor(key, association, type) {
+    #hasFallback = false;
+    #fallback;
+    constructor(key, type, options = {}) {
         this.#key = key;
-        this.#association = association;
+        this.#association = options.name ?? key;
         this.#type = type;
+        if (!("fallback" in options))
+            return;
+        this.#hasFallback = true;
+        this.#fallback = type.export(options.fallback);
     }
-    get key() {
-        return this.#key;
+    get key() { return this.#key; }
+    get association() { return this.#association; }
+    import(object, name) {
+        const association = this.#association;
+        const raw = Reflect.get(object, association);
+        const source = raw === undefined && this.#hasFallback ? this.#fallback : raw;
+        return this.#type.import(source, `${name}.${association}`);
     }
-    get association() {
-        return this.#association;
-    }
-    get type() {
-        return this.#type;
+    export(source) {
+        return this.#type.export(Reflect.get(source, this.#key));
     }
 }
-//#endregion
-//#region Descendant descriptor
 class DescendantDescriptor {
     #type;
     #discriminator;
@@ -38,15 +45,99 @@ class DescendantDescriptor {
         this.#type = type;
         this.#discriminator = discriminator;
     }
-    get type() {
-        return this.#type;
+    get discriminator() { return this.#discriminator ?? this.#type.name; }
+    accepts(discriminator) {
+        return this.discriminator === discriminator;
+    }
+    owns(instance) {
+        return instance instanceof this.#type;
     }
-    get discriminator() {
-        return this.#discriminator ?? this.#type.name;
+    import(source, name) {
+        return this.#type.import(source, name);
+    }
+    export(source) {
+        return this.#type.export(source);
+    }
+}
+class ModelSchema {
+    static #schemas = new WeakMap();
+    static #collect(object) {
+        const fields = new Map();
+        let current = object;
+        while (current !== null) {
+            for (const [key, descriptor] of PortabilityMetadata.for(current).fields)
+                fields.add(key, descriptor);
+            current = Object.getPrototypeOf(current);
+        }
+        return fields;
+    }
+    static resolve(model) {
+        const schemas = ModelSchema.#schemas;
+        let schema = schemas.get(model);
+        if (schema !== undefined)
+            return schema;
+        const object = ReferenceError.suppress(model[Symbol.metadata], `Required an implementation of Symbol.metadata in '${model.name}' to use portability`);
+        const { discriminator, descendants } = Object.hasOwn(model, Symbol.metadata)
+            ? PortabilityMetadata.for(object)
+            : new PortabilityMetadata();
+        schema = descendants.length > 0
+            ? new PolymorphicSchema(discriminator, descendants)
+            : new ConcreteSchema(model, ModelSchema.#collect(object));
+        schemas.set(model, schema);
+        return schema;
+    }
+}
+class ConcreteSchema extends ModelSchema {
+    #model;
+    #fields;
+    constructor(model, fields) {
+        super();
+        this.#model = model;
+        this.#fields = fields;
+    }
+    import(source, name) {
+        const object = Object.import(source, name);
+        const instance = Reflect.construct(this.#model, []);
+        for (const descriptor of this.#fields.values())
+            Reflect.set(instance, descriptor.key, descriptor.import(object, name));
+        return instance;
+    }
+    export(source) {
+        const target = new Object();
+        for (const descriptor of this.#fields.values())
+            Reflect.set(target, descriptor.association, descriptor.export(source));
+        return target;
+    }
+}
+class PolymorphicSchema extends ModelSchema {
+    #discriminator;
+    #descendants;
+    constructor(discriminator, descendants) {
+        super();
+        this.#discriminator = discriminator;
+        this.#descendants = descendants;
+    }
+    import(source, name) {
+        const key = this.#discriminator;
+        const object = Object.import(source, name);
+        const value = Reflect.get(object, key);
+        if (value === undefined)
+            throw new TypeError(`Missing '${key}' discriminator in ${name}`);
+        const discriminator = String.import(value, `${name}.${key}`);
+        const descriptor = this.#descendants.find(descendant => descendant.accepts(discriminator));
+        if (descriptor === undefined)
+            throw new TypeError(`Unknown '${discriminator}' discriminator for ${name}`);
+        return descriptor.import(source, name);
+    }
+    export(source) {
+        const descriptor = this.#descendants.find(descendant => descendant.owns(source));
+        if (descriptor === undefined)
+            throw new TypeError(`Invalid '${typename(source)}' type for source`);
+        const exported = descriptor.export(source);
+        Reflect.set(exported, this.#discriminator, descriptor.discriminator);
+        return exported;
     }
 }
-//#endregion
-//#region Portability metadata
 class PortabilityMetadata {
     static #registry = new WeakMap();
     #fields = new Map();
@@ -61,40 +152,10 @@ class PortabilityMetadata {
         registry.set(metadata, entry);
         return entry;
     }
-    static read(model) {
-        const object = ReferenceError.suppress(model[Symbol.metadata], `Required an implementation of Symbol.metadata in '${model.name}' to use portability`);
-        const metadata = PortabilityMetadata.for(object);
-        const fields = metadata.#fields;
-        let current = object;
-        while (true) {
-            if (current === null)
-                break;
-            for (const [key, descriptor] of PortabilityMetadata.for(current).#fields)
-                fields.add(key, descriptor);
-            current = Object.getPrototypeOf(current);
-        }
-        return metadata;
-    }
-    static descendantsOf(model) {
-        if (!Object.hasOwn(model, Symbol.metadata))
-            return [];
-        const object = model[Symbol.metadata];
-        if (object === null || object === undefined)
-            return [];
-        return PortabilityMetadata.for(object).#descendants;
-    }
-    get fields() {
-        return this.#fields;
-    }
-    get descendants() {
-        return this.#descendants;
-    }
-    get discriminator() {
-        return this.#discriminator;
-    }
-    set discriminator(value) {
-        this.#discriminator = value;
-    }
+    get fields() { return this.#fields; }
+    get descendants() { return this.#descendants; }
+    get discriminator() { return this.#discriminator; }
+    set discriminator(value) { this.#discriminator = value; }
 }
 //#endregion
 //#region Model
@@ -110,89 +171,28 @@ export class Model {
      * @throws {TypeError} If validation fails or types do not match.
      */
     static import(source, name) {
-        const model = this;
-        const descendants = PortabilityMetadata.descendantsOf(model);
-        if (descendants.length > 0) {
-            const { discriminator: key } = PortabilityMetadata.read(model);
-            const object = Object.import(source, name);
-            const value = Reflect.get(object, key);
-            if (value === undefined)
-                throw new TypeError(`Missing '${key}' discriminator in ${name}`);
-            const discriminator = String.import(value, `${name}.${key}`);
-            const descriptor = descendants.find(descriptor => descriptor.discriminator === discriminator);
-            if (descriptor === undefined)
-                throw new TypeError(`Unknown '${discriminator}' discriminator for ${name}`);
-            return descriptor.type.import(source, name);
-        }
-        const object = Object.import(source, name);
-        const instance = Reflect.construct(this, []);
-        const { fields } = PortabilityMetadata.read(model);
-        for (const { key, association, type } of fields.values()) {
-            const raw = Reflect.get(object, association);
-            const value = type.import(raw, `${name}.${association}`);
-            Reflect.set(instance, key, value);
-        }
-        return instance;
+        return ModelSchema.resolve(this).import(source, name);
     }
     /**
      * Serializes the model instance to a raw object.
      * @param source The model instance to export.
      */
     static export(source) {
-        const model = this;
-        const descendants = PortabilityMetadata.descendantsOf(model);
-        if (descendants.length > 0) {
-            const { discriminator: key } = PortabilityMetadata.read(model);
-            const descriptor = descendants.find(descriptor => source instanceof descriptor.type);
-            if (descriptor === undefined)
-                throw new TypeError(`Invalid '${typename(source)}' type for source`);
-            const descendant = descriptor.type;
-            const exported = descendant.export(source);
-            Reflect.set(exported, key, descriptor.discriminator);
-            return exported;
-        }
-        const object = new Object();
-        const { fields } = PortabilityMetadata.read(model);
-        for (const { key, association, type } of fields.values()) {
-            const value = Reflect.get(source, key);
-            const raw = type.export(value);
-            Reflect.set(object, association, raw);
-        }
-        return object;
+        return ModelSchema.resolve(this).export(source);
     }
 }
-export function Field(type, name) {
+export function Field(type, options = {}) {
     return function (_, context) {
         if (context.static)
             throw new TypeError("Portable fields cannot be static");
         const key = context.name;
         if (typeof (key) === "symbol")
             throw new TypeError("Symbols are not supported as portable keys");
-        const association = name ?? key;
         const { fields } = PortabilityMetadata.for(context.metadata);
         if (!fields.has(key))
-            fields.set(key, new FieldDescriptor(key, association, type));
-    };
-}
-export function Descendant(descendant, discriminator) {
-    return function (model, context) {
-        void model;
-        const { descendants } = PortabilityMetadata.for(context.metadata);
-        descendants.push(new DescendantDescriptor(descendant, discriminator));
-    };
-}
-/**
- * Decorator to register a custom discriminator key for the polymorphic model.
- * @param key The property key to use for the discriminator.
- */
-export function DiscriminatorKey(key) {
-    return function (model, context) {
-        void model;
-        PortabilityMetadata.for(context.metadata).discriminator = key;
+            fields.set(key, new FieldDescriptor(key, type, options));
     };
 }
-//#endregion
-//#region Adapters
 /**
  * Creates a wrapper for circular or deferred type references.
  * @param resolver Function that returns the actual type constructor.
@@ -213,224 +213,159 @@ export function Deferred(resolver) {
         },
     };
 }
-/**
- * Creates a portable wrapper for optional types.
- * @param type The inner portable type.
- */
-export function Optional(type) {
-    return {
-        [Symbol.hasInstance](instance) {
-            return instance === undefined || type[Symbol.hasInstance](instance);
-        },
-        get name() {
-            return `${type.name} | undefined`;
-        },
-        import(source, name) {
-            return Reflect.mapUndefined(source, source => type.import(source, name));
-        },
-        export(source) {
-            return Reflect.mapUndefined(source, source => type.export(source));
-        },
-    };
-}
-/**
- * Creates a portable wrapper for nullable types.
- * @param type The inner portable type.
- */
-export function Nullable(type) {
-    return {
-        [Symbol.hasInstance](instance) {
-            return instance === null || type[Symbol.hasInstance](instance);
-        },
-        get name() {
-            return `${type.name} | null`;
-        },
-        import(source, name) {
-            return Reflect.mapNull(source, source => type.import(source, name));
-        },
-        export(source) {
-            return Reflect.mapNull(source, source => type.export(source));
-        },
-    };
-}
-/**
- * Creates a portable wrapper for array types.
- * @param type The portable type of the array elements.
- */
-export function ArrayOf(type) {
-    return {
-        [Symbol.hasInstance](instance) {
-            return Array[Symbol.hasInstance](instance);
-        },
-        get name() {
-            return `${type.name}[]`;
-        },
-        import(source, name) {
-            return Array.import(source, name).map((item, index) => type.import(item, `${name}[${index}]`));
-        },
-        export(source) {
-            return source.map(item => type.export(item));
-        },
+export function Descendant(descendant, discriminator) {
+    return function (model, context) {
+        void model;
+        const { descendants } = PortabilityMetadata.for(context.metadata);
+        descendants.push(new DescendantDescriptor(descendant, discriminator));
     };
 }
 /**
- * Creates a portable wrapper for set types.
- * @param type The portable type of the set elements.
+ * Decorator to register a custom discriminator key for the polymorphic model.
+ * @param key The property key to use for the discriminator.
  */
-export function SetOf(type) {
-    return {
-        [Symbol.hasInstance](instance) {
-            return Set[Symbol.hasInstance](instance);
-        },
-        get name() {
-            return `Set<${type.name}>`;
-        },
-        import(source, name) {
-            return new Set(Array.import(source, name).map((item, index) => type.import(item, `${name}[${index}]`)));
-        },
-        export(source) {
-            return Array.from(source, item => type.export(item));
-        },
+export function DiscriminatorKey(key) {
+    return function (model, context) {
+        void model;
+        PortabilityMetadata.for(context.metadata).discriminator = key;
     };
 }
+//#endregion
+//#region Adapters
 /**
- * Creates a portable wrapper for maps with string keys, converting them to and from plain objects.
- * @param value The portable type of the map values.
+ * Portable adapter class for optional (possibly-undefined) types.
+ * Use `Optional.Of(type)` to wrap an adapter, and `Optional.map` for conditional mapping.
  */
-export function RecordOf(type) {
-    return {
-        [Symbol.hasInstance](instance) {
-            return Map[Symbol.hasInstance](instance);
-        },
-        get name() {
-            return `Map<string, ${type.name}>`;
-        },
-        import(source, name) {
-            const record = Object.import(source, name);
-            const map = new Map();
-            for (const key of Object.keys(record)) {
-                map.set(key, type.import(Reflect.get(record, key), `${name}[${JSON.stringify(key)}]`));
-            }
-            return map;
-        },
-        export(source) {
-            const record = {};
-            for (const [key, value] of source) {
-                Reflect.set(record, key, type.export(value));
-            }
-            return record;
-        },
-    };
+export class Optional {
+    constructor() {
+        throw new TypeError("Unable to create an instance of a static class");
+    }
+    /**
+     * Creates a portable wrapper for optional types.
+     * @param type The inner portable type.
+     */
+    static Of(type) {
+        return {
+            [Symbol.hasInstance](instance) {
+                return type[Symbol.hasInstance](instance);
+            },
+            get name() {
+                return `${type.name} | undefined`;
+            },
+            import(source, name) {
+                return Optional.map(source, source => type.import(source, name));
+            },
+            export(source) {
+                return Optional.map(source, source => type.export(source));
+            },
+        };
+    }
+    /**
+     * Applies a callback to a non-undefined value, or passes through `undefined` unchanged.
+     * @param value The value to map.
+     * @param callback The function to apply if the value is not undefined.
+     */
+    static map(value, callback) {
+        if (value === undefined)
+            return value;
+        return callback(value);
+    }
 }
 /**
- * Creates a portable wrapper for maps with arbitrary key and value types, converting them to and from arrays of `[key, value]` tuples.
- * @param key The portable type of the map keys.
- * @param value The portable type of the map values.
+ * Portable adapter class for nullable (possibly-null) types.
+ * Use `Nullable.Of(type)` to wrap an adapter, and `Nullable.map` for conditional mapping.
  */
-export function MapOf(typeKey, typeValue) {
-    return {
-        [Symbol.hasInstance](instance) {
-            return Map[Symbol.hasInstance](instance);
-        },
-        get name() {
-            return `Map<${typeKey.name}, ${typeValue.name}>`;
-        },
-        import(source, name) {
-            return new Map(Array.import(source, name).map((item, index) => {
-                const tuple = Array.import(item, `${name}[${index}]`);
-                const key = typeKey.import(tuple[0], `${name}[${index}][0]`);
-                const value = typeValue.import(tuple[1], `${name}[${index}][1]`);
-                return [key, value];
-            }));
-        },
-        export(source) {
-            return Array.from(source, ([key, value]) => [typeKey.export(key), typeValue.export(value)]);
-        },
-    };
+export class Nullable {
+    constructor() {
+        throw new TypeError("Unable to create an instance of a static class");
+    }
+    /**
+     * Creates a portable wrapper for nullable types.
+     * @param type The inner portable type.
+     */
+    static Of(type) {
+        return {
+            [Symbol.hasInstance](instance) {
+                return type[Symbol.hasInstance](instance);
+            },
+            get name() {
+                return `${type.name} | null`;
+            },
+            import(source, name) {
+                return Nullable.map(source, source => type.import(source, name));
+            },
+            export(source) {
+                return Nullable.map(source, source => type.export(source));
+            },
+        };
+    }
+    /**
+     * Applies a callback to a non-null value, or passes through `null` unchanged.
+     * @param value The value to map.
+     * @param callback The function to apply if the value is not null.
+     */
+    static map(value, callback) {
+        if (value === null)
+            return value;
+        return callback(value);
+    }
 }
 /**
- * Creates a portable wrapper for enum types, strictly operating only on enum values.
- * @param reference The enum object reference.
+ * Portable adapter class for enum types.
+ * Use `Enum.Of(reference)` to create an adapter that validates against enum values.
  */
-export function EnumAs(reference) {
-    const values = new Set();
-    for (const [key, value] of Object.entries(reference)) {
-        const index = Number(key);
-        if (String(index) === key && typeof value === "string" && Reflect.get(reference, value) === index)
-            continue;
-        values.add(value);
+export class Enum {
+    constructor() {
+        throw new TypeError("Unable to create an instance of a static class");
+    }
+    /**
+     * Creates a portable wrapper for enum types, strictly operating only on enum values.
+     * @param reference The enum object reference.
+     */
+    static Of(reference) {
+        const values = new Set();
+        for (const [key, value] of Object.entries(reference)) {
+            const index = Number(key);
+            if (String(index) === key && typeof value === "string" && Reflect.get(reference, value) === index)
+                continue;
+            values.add(value);
+        }
+        return {
+            [Symbol.hasInstance](instance) {
+                return values.has(instance);
+            },
+            get name() {
+                return "Enum";
+            },
+            import(source, name) {
+                if (!values.has(source))
+                    throw new TypeError(`Unable to import enum from ${name} due to invalid value`);
+                return source;
+            },
+            export(source) {
+                return source;
+            },
+        };
     }
-    return {
-        [Symbol.hasInstance](instance) {
-            return values.has(instance);
-        },
-        get name() {
-            return "Enum";
-        },
-        import(source, name) {
-            if (!values.has(source))
-                throw new TypeError(`Unable to import enum from ${name} due to invalid value`);
-            return source;
-        },
-        export(source) {
-            return source;
-        },
-    };
 }
 /**
- * A portable adapter that facilitates the conversion between `Date` instances and millisecond timestamps.
- */
-export const Timestamp = {
-    [Symbol.hasInstance](instance) {
-        return Date[Symbol.hasInstance](instance);
-    },
-    get name() {
-        return "Timestamp";
-    },
-    import(source, name) {
-        if (typeof (source) !== "number")
-            throw new TypeError(`Unable to import date from ${name} due its ${typename(source)} type`);
-        return new Date(source);
-    },
-    export(source) {
-        return source.getTime();
-    },
-};
-/**
- * A portable adapter that facilitates the conversion between `Date` instances and Unix second timestamps.
- */
-export const UnixSeconds = {
-    [Symbol.hasInstance](instance) {
-        return Date[Symbol.hasInstance](instance);
-    },
-    get name() {
-        return "UnixSeconds";
-    },
-    import(source, name) {
-        if (typeof (source) !== "number")
-            throw new TypeError(`Unable to import date from ${name} due its ${typename(source)} type`);
-        return new Date(source * 1000);
-    },
-    export(source) {
-        return Math.trunc(source.getTime() / 1000);
-    },
-};
-/**
- * A portable adapter that allows any value to pass through without validation or transformation.
+ * Portable adapter class for unknown/any types.
+ * Pass `Any` directly to `@Field` to allow any value without validation or transformation.
  */
-export const Any = {
-    [Symbol.hasInstance](instance) {
+export class Any {
+    constructor() {
+        throw new TypeError("Unable to create an instance of a static class");
+    }
+    static [Symbol.hasInstance](instance) {
         void instance;
         return true;
-    },
-    get name() {
-        return "Any";
-    },
-    import(source, name) {
+    }
+    static import(source, name) {
         void name;
         return source;
-    },
-    export(source) {
+    }
+    static export(source) {
         return source;
-    },
-};
+    }
+}
+//# sourceMappingURL=portable.js.map