@decaf-ts/decoration 0.0.2

package/dist/decoration.esm.cjs

@@ -0,0 +1,633 @@
+import 'reflect-metadata';
+
+/**
+ * @description Default flavour identifier for the decorator system
+ * @summary Defines the default flavour used by the Decoration class when no specific flavour is provided.
+ * This constant is used throughout the library as the fallback flavour for decorators.
+ * @const DefaultFlavour
+ * @memberOf module:decoration
+ */
+const DefaultFlavour = "decaf";
+/**
+ * @description Character used to split nested metadata keys
+ * @summary The delimiter used by the metadata store to traverse nested object paths when reading/writing values.
+ * @const ObjectKeySplitter
+ * @memberOf module:decoration
+ */
+const ObjectKeySplitter = ".";
+/**
+ * @description Enum containing metadata keys used for reflection in the model system
+ * @summary Defines the various Model keys used for reflection and metadata storage.
+ * These keys are used throughout the library to store and retrieve metadata about models,
+ * their properties, and their behavior.
+ * @readonly
+ * @enum {string}
+ * @readonly
+ * @memberOf module:decoration
+ */
+var DecorationKeys;
+(function (DecorationKeys) {
+    /** Storage key used on the constructor to mirror runtime metadata */
+    DecorationKeys["REFLECT"] = "__decaf";
+    /** Map of model property keys to their reflected design types */
+    DecorationKeys["PROPERTIES"] = "properties";
+    /** Key under which the model's constructor is stored */
+    DecorationKeys["CLASS"] = "class";
+    /** Container of human-friendly descriptions per class and property */
+    DecorationKeys["DESCRIPTION"] = "description";
+    /** Reflect metadata key for design time type of a property */
+    DecorationKeys["DESIGN_TYPE"] = "design:type";
+    /** Reflect metadata key for constructor parameter types */
+    DecorationKeys["DESIGN_PARAMS"] = "design:paramtypes";
+    /** Reflect metadata key for method return type */
+    DecorationKeys["DESIGN_RETURN"] = "design:returntype";
+})(DecorationKeys || (DecorationKeys = {}));
+/**
+ * @description Typedef for the default metadata object shape
+ * @summary Describes the minimal structure persisted for a model before any metadata is recorded.
+ * @template M
+ * @typedef {object} DefaultMetadataType<M>
+ * @property {Record<string, Constructor | undefined>} properties - Mapping of property names to their design types
+ * @memberOf module:decoration
+ */
+/**
+ * @description Default metadata instance
+ * @summary Concrete default metadata object used when initializing metadata for a model
+ * @type {DefaultMetadataType<any>}
+ * @const DefaultMetadata
+ * @memberOf module:decoration
+ */
+const DefaultMetadata = {
+    [DecorationKeys.PROPERTIES]: [],
+};
+
+/**
+ * @description Default resolver that returns the current default flavour
+ * @summary Resolves the flavour for a given target by always returning the library's DefaultFlavour value.
+ * @param {object} target The target object being decorated
+ * @return {string} The resolved flavour identifier
+ * @function defaultFlavourResolver
+ * @memberOf module:decoration
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function defaultFlavourResolver(target) {
+    return DefaultFlavour;
+}
+/**
+ * @description A decorator management class that handles flavoured decorators
+ * @summary The Decoration class provides a builder pattern for creating and managing decorators with different flavours.
+ * It supports registering, extending, and applying decorators with context-aware flavour resolution.
+ * The class implements a fluent interface for defining, extending, and applying decorators with different flavours,
+ * allowing for framework-specific decorator implementations while maintaining a consistent API.
+ * @template T Type of the decorator (ClassDecorator | PropertyDecorator | MethodDecorator)
+ * @param {string} [flavour] Optional flavour parameter for the decorator context
+ * @class
+ * @example
+ * ```typescript
+ * // Create a new decoration for 'component' with default flavour
+ * const componentDecorator = new Decoration()
+ *   .for('component')
+ *   .define(customComponentDecorator);
+ *
+ * // Create a flavoured decoration
+ * const vueComponent = new Decoration('vue')
+ *   .for('component')
+ *   .define(vueComponentDecorator);
+ *
+ * // Apply the decoration
+ * @componentDecorator
+ * class MyComponent {}
+ * ```
+ * @mermaid
+ * sequenceDiagram
+ *   participant C as Client
+ *   participant D as Decoration
+ *   participant R as FlavourResolver
+ *   participant F as DecoratorFactory
+ *
+ *   C->>D: new Decoration(flavour)
+ *   C->>D: for(key)
+ *   C->>D: define(decorators)
+ *   D->>D: register(key, flavour, decorators)
+ *   D->>F: decoratorFactory(key, flavour)
+ *   F->>R: resolve(target)
+ *   R-->>F: resolved flavour
+ *   F->>F: apply decorators
+ *   F-->>C: decorated target
+ */
+class Decoration {
+    /**
+     * @description Static map of registered decorators
+     * @summary Stores all registered decorators organized by key and flavour
+     */
+    static { this.decorators = {}; }
+    /**
+     * @description Function to resolve flavour from a target
+     * @summary Resolver function that determines the appropriate flavour for a given target
+     */
+    static { this.flavourResolver = defaultFlavourResolver; }
+    constructor(flavour = DefaultFlavour) {
+        this.flavour = flavour;
+    }
+    /**
+     * @description Sets the key for the decoration builder
+     * @summary Initializes a new decoration chain with the specified key
+     * @param {string} key The identifier for the decorator
+     * @return {DecorationBuilderMid} Builder instance for method chaining
+     */
+    for(key) {
+        this.key = key;
+        return this;
+    }
+    /**
+     * @description Adds decorators to the current context
+     * @summary Internal method to add decorators with addon support
+     * @param {boolean} [addon=false] Whether the decorators are addons
+     * @param decorators Array of decorators
+     * @return {this} Current instance for chaining
+     */
+    decorate(addon = false, ...decorators) {
+        if (!this.key)
+            throw new Error("key must be provided before decorators can be added");
+        if ((!decorators || !decorators.length) &&
+            !addon &&
+            this.flavour !== DefaultFlavour)
+            throw new Error("Must provide overrides or addons to override or extend decaf's decorators");
+        if (this.flavour === DefaultFlavour && addon)
+            throw new Error("Default flavour cannot be extended");
+        this[addon ? "extras" : "decorators"] = new Set([
+            ...(this[addon ? "extras" : "decorators"] || new Set()).values(),
+            ...decorators,
+        ]);
+        return this;
+    }
+    /**
+     * @description Defines the base decorators
+     * @summary Sets the primary decorators for the current context
+     * @param decorators Decorators to define
+     * @return Builder instance for finishing the chain
+     */
+    define(...decorators) {
+        return this.decorate(false, ...decorators);
+    }
+    /**
+     * @description Extends existing decorators
+     * @summary Adds additional decorators to the current context
+     * @param decorators Additional decorators
+     * @return {DecorationBuilderBuild} Builder instance for building the decorator
+     */
+    extend(...decorators) {
+        return this.decorate(true, ...decorators);
+    }
+    /**
+     * @description Factory that creates a context-aware decorator for a key/flavour
+     * @summary Produces a decorator function bound to the provided key and flavour. The resulting decorator resolves the actual
+     * decorators to apply at invocation time based on the target's resolved flavour and the registered base and extra decorators.
+     * @param {string} key The decoration key used to look up registered decorators
+     * @param {string} [f=DefaultFlavour] Optional explicit flavour to bind the factory to
+     * @return {function(object, any, TypedPropertyDescriptor<any>): any} A decorator function that applies the resolved decorators
+     * @mermaid
+     * sequenceDiagram
+     *   participant U as User Code
+     *   participant B as Decoration (builder)
+     *   participant F as decoratorFactory(key, f)
+     *   participant R as flavourResolver
+     *   participant A as Applied Decorators
+     *   U->>B: define()/extend() and apply()
+     *   B->>F: create context decorator
+     *   F->>R: resolve(target)
+     *   R-->>F: flavour
+     *   F->>A: collect base + extras
+     *   loop each decorator
+     *     A->>U: invoke decorator(target, key?, desc?)
+     *   end
+     */
+    decoratorFactory(key, f = DefaultFlavour) {
+        function contextDecorator(target, propertyKey, descriptor) {
+            const flavour = Decoration.flavourResolver(target);
+            const cache = Decoration.decorators[key];
+            let decorators;
+            const extras = cache[flavour]
+                ? cache[flavour].extras
+                : cache[DefaultFlavour].extras;
+            const extraArgs = [
+                ...(cache[DefaultFlavour].extras
+                    ? cache[DefaultFlavour].extras.values()
+                    : []),
+            ].reduce((accum, e, i) => {
+                if (e.args)
+                    accum[i] = e.args;
+                return accum;
+            }, {});
+            if (cache &&
+                cache[flavour] &&
+                cache[flavour].decorators &&
+                cache[flavour].decorators.size) {
+                decorators = cache[flavour].decorators;
+            }
+            else {
+                decorators = cache[DefaultFlavour].decorators;
+            }
+            const decoratorArgs = [
+                ...cache[DefaultFlavour].decorators.values(),
+            ].reduce((accum, e, i) => {
+                if (e.args)
+                    accum[i] = e.args;
+                return accum;
+            }, {});
+            const toApply = [
+                ...(decorators ? decorators.values() : []),
+                ...(extras ? extras.values() : []),
+            ];
+            return toApply.reduce((_, d, i) => {
+                switch (typeof d) {
+                    case "object": {
+                        const { decorator, args } = d;
+                        const argz = args || i < (decorators ? decorators.size : 0)
+                            ? decoratorArgs[i]
+                            : extraArgs[i - (decorators ? decorators.size : 0)] ||
+                                (decorators ? decoratorArgs[i - decorators.size] : []);
+                        return decorator(...(argz || []))(target, propertyKey, descriptor);
+                    }
+                    case "function":
+                        return d(target, propertyKey, descriptor);
+                    default:
+                        throw new Error(`Unexpected decorator type: ${typeof d}`);
+                }
+            }, { target, propertyKey, descriptor });
+        }
+        Object.defineProperty(contextDecorator, "name", {
+            value: [f, key].join("_decorator_for_"),
+            writable: false,
+        });
+        return contextDecorator;
+    }
+    /**
+     * @description Creates the final decorator function
+     * @summary Builds and returns the decorator factory function
+     * @return {function(any, any?, TypedPropertyDescriptor?): any} The generated decorator function
+     */
+    apply() {
+        if (!this.key)
+            throw new Error("No key provided for the decoration builder");
+        Decoration.register(this.key, this.flavour, this.decorators || new Set(), this.extras);
+        return this.decoratorFactory(this.key, this.flavour);
+    }
+    /**
+     * @description Registers decorators for a specific key and flavour
+     * @summary Internal method to store decorators in the static registry
+     * @param {string} key Decorator key
+     * @param {string} flavour Decorator flavour
+     * @param [decorators] Primary decorators
+     * @param [extras] Additional decorators
+     */
+    static register(key, flavour, decorators, extras) {
+        if (!key) {
+            throw new Error("No key provided for the decoration builder");
+        }
+        if (!decorators)
+            throw new Error("No decorators provided for the decoration builder");
+        if (!flavour)
+            throw new Error("No flavour provided for the decoration builder");
+        if (!Decoration.decorators[key])
+            Decoration.decorators[key] = {};
+        if (!Decoration.decorators[key][flavour])
+            Decoration.decorators[key][flavour] = {};
+        if (decorators)
+            Decoration.decorators[key][flavour].decorators = decorators;
+        if (extras)
+            Decoration.decorators[key][flavour].extras = extras;
+    }
+    /**
+     * @description Sets the global flavour resolver
+     * @summary Configures the function used to determine decorator flavours
+     * @param {FlavourResolver} resolver Function to resolve flavours
+     */
+    static setFlavourResolver(resolver) {
+        Decoration.flavourResolver = resolver;
+    }
+    /**
+     * @description Convenience static entry to start a decoration builder
+     * @summary Creates a new Decoration instance and initiates the builder chain with the provided key.
+     * @param {string} key The decoration key to configure
+     * @return {DecorationBuilderMid} A builder instance for chaining definitions
+     */
+    static for(key) {
+        return new Decoration().for(key);
+    }
+    /**
+     * @description Starts a builder for a specific flavour
+     * @summary Convenience method to begin a Decoration builder chain bound to the given flavour identifier, allowing registration of flavour-specific decorators.
+     * @param {string} flavour The flavour name to bind to the builder
+     * @return {DecorationBuilderStart} A builder start interface to continue configuration
+     */
+    static flavouredAs(flavour) {
+        return new Decoration(flavour);
+    }
+}
+
+/**
+ * @description Retrieves a nested value from an object given a path
+ * @summary Walks an object structure using a splitter-delimited path and returns the value at that location or undefined if any key is missing.
+ * @param {Record<string, any>} obj The object to traverse
+ * @param {string} path The path to the desired value (e.g., "a.b.c")
+ * @param {string} [splitter=ObjectKeySplitter] The delimiter used to split the path
+ * @return {*} The resolved value at the given path or undefined if not found
+ * @function getValueBySplitter
+ * @mermaid
+ * sequenceDiagram
+ *   participant C as Caller
+ *   participant F as getValueBySplitter
+ *   participant O as Object
+ *   C->>F: (obj, path, splitter)
+ *   F->>F: split path into keys
+ *   loop for each key
+ *     F->>O: access current[key]
+ *     alt missing or nullish
+ *       F-->>C: return undefined
+ *     end
+ *   end
+ *   F-->>C: return final value
+ * @memberOf module:decoration
+ */
+function getValueBySplitter(obj, path, splitter = ObjectKeySplitter) {
+    const keys = path.split(splitter);
+    let current = obj;
+    for (const key of keys) {
+        if (current === null ||
+            current === undefined ||
+            !Object.prototype.hasOwnProperty.call(current, key))
+            return undefined;
+        current = current[key];
+    }
+    return current;
+}
+/**
+ * @description Sets a nested value on an object given a path
+ * @summary Traverses or creates intermediate objects following a splitter-delimited path and assigns the provided value at the destination key.
+ * @param {Record<string, any>} obj The object to mutate
+ * @param {string} path The destination path (e.g., "a.b.c")
+ * @param {*} value The value to set at the destination
+ * @param {string} [splitter=ObjectKeySplitter] The delimiter used to split the path
+ * @return {void}
+ * @function setValueBySplitter
+ * @mermaid
+ * sequenceDiagram
+ *   participant C as Caller
+ *   participant F as setValueBySplitter
+ *   participant O as Object
+ *   C->>F: (obj, path, value, splitter)
+ *   F->>F: split path into keys
+ *   loop for each key
+ *     alt key missing
+ *       F->>O: create intermediate object
+ *     else key exists
+ *       F->>O: descend into existing object
+ *     end
+ *   end
+ *   F-->>C: void
+ * @memberOf module:decoration
+ */
+function setValueBySplitter(obj, path, value, splitter = ObjectKeySplitter) {
+    const keys = path.split(splitter).filter((k) => k.length > 0);
+    if (keys.length === 0)
+        return;
+    let current = obj;
+    for (let i = 0; i < keys.length - 1; i++) {
+        const key = keys[i];
+        if (current[key] === undefined ||
+            current[key] === null ||
+            typeof current[key] !== "object") {
+            current[key] = {};
+        }
+        current = current[key];
+    }
+    const lastKey = keys[keys.length - 1];
+    current[lastKey] = value;
+}
+/**
+ * @description Centralized runtime metadata store bound to constructors
+ * @summary Provides utilities to read and write structured metadata for classes and their members, with optional mirroring onto the constructor via a well-known symbol key. Supports nested key paths using a configurable splitter and offers both instance and static APIs.
+ * @template M The model type the metadata belongs to
+ * @template META Extends BasicMetadata<M> representing the metadata structure
+ * @class
+ * @example
+ * // Define and read metadata for a class
+ * class User { name!: string }
+ * Metadata.set(User, "description.class", "A user model");
+ * Metadata.set(User, "properties.name", String);
+ * const desc = Metadata.get(User, "description.class"); // "A user model"
+ * const type = Metadata.type(User, "name"); // String
+ * @mermaid
+ * sequenceDiagram
+ *   participant C as Constructor
+ *   participant S as Metadata (static)
+ *   C->>S: set(User, "properties.name", String)
+ *   C->>S: get(User, "properties.name")
+ *   S-->>C: String
+ */
+class Metadata {
+    /**
+     * @description In-memory storage of metadata by constructor symbol
+     * @summary Maps a Symbol derived from the constructor to its metadata object, enabling efficient lookup.
+     */
+    static { this._metadata = {}; }
+    /**
+     * @description Path delimiter for nested metadata keys
+     * @summary Used by get/set operations to navigate nested structures, defaults to ObjectKeySplitter.
+     */
+    static { this.splitter = ObjectKeySplitter; }
+    /**
+     * @description Symbol key used to mirror metadata on the constructor
+     * @summary When mirroring is enabled, the metadata object is defined on the constructor under this non-enumerable key.
+     */
+    static { this.baseKey = DecorationKeys.REFLECT; }
+    /**
+     * @description Controls whether metadata is mirrored onto the constructor
+     * @summary When true, the metadata object is defined on the constructor under the non-enumerable baseKey.
+     */
+    static { this.mirror = true; }
+    constructor() { }
+    /**
+     * @description Lists known property keys for a model
+     * @summary Reads the metadata entry and returns the names of properties that have recorded type information.
+     * @param {Constructor} model The target constructor
+     * @return {string[]|undefined} Array of property names or undefined if no metadata exists
+     */
+    static properties(model) {
+        const meta = this.get(model);
+        if (!meta)
+            return undefined;
+        return Object.keys(meta.properties);
+    }
+    /**
+     * @description Retrieves a human-readable description for a class or a property
+     * @summary Looks up the description stored under the metadata "description" map. If a property key is provided, returns the property's description; otherwise returns the class description.
+     * @template M
+     * @param {Constructor<M>} model The target constructor whose description is being retrieved
+     * @param {string} [prop] Optional property key for which to fetch the description
+     * @return {string|undefined} The description text if present, otherwise undefined
+     */
+    static description(model, prop) {
+        return this.get(model, [DecorationKeys.DESCRIPTION, prop ? prop : DecorationKeys.CLASS].join(ObjectKeySplitter));
+    }
+    /**
+     * @description Retrieves the recorded design type for a property
+     * @summary Reads the metadata entry under "properties.<prop>" to return the constructor recorded for the given property name.
+     * @param {Constructor} model The target constructor
+     * @param {string} prop The property name whose type should be returned
+     * @return {Constructor|undefined} The constructor reference of the property type or undefined if not available
+     */
+    static type(model, prop) {
+        return this.get(model, `${DecorationKeys.PROPERTIES}.${prop}`);
+    }
+    /**
+     * @description Retrieves metadata for a model or a specific key within it
+     * @summary When called with a constructor only, returns the entire metadata object associated with the model. When a key path is provided, returns the value stored at that nested key.
+     * @template M
+     * @template META
+     * @param {Constructor<M>} model The target constructor used to locate the metadata record
+     * @param {string} [key] Optional nested key path to fetch a specific value
+     * @return {META|*|undefined} The metadata object, the value at the key path, or undefined if nothing exists
+     */
+    static get(model, key) {
+        const symbol = Symbol.for(model.toString());
+        if (!this._metadata[symbol])
+            return undefined;
+        if (!key)
+            return this._metadata[symbol];
+        return getValueBySplitter(this._metadata[symbol], key, this.splitter);
+    }
+    /**
+     * @description Writes a metadata value at a given nested key path
+     * @summary Ensures the metadata record exists for the constructor, mirrors it on the constructor when enabled, and sets the provided value on the nested key path using the configured splitter.
+     * @param {Constructor} model The target constructor to which the metadata belongs
+     * @param {string} key The nested key path at which to store the value
+     * @param {*} value The value to store in the metadata
+     * @return {void}
+     */
+    static set(model, key, value) {
+        const symbol = Symbol.for(model.toString());
+        if (!this._metadata[symbol])
+            this._metadata[symbol] = {};
+        if (Metadata.mirror &&
+            !Object.prototype.hasOwnProperty.call(model, this.baseKey)) {
+            Object.defineProperty(model, this.baseKey, {
+                enumerable: false,
+                configurable: false,
+                writable: false,
+                value: this._metadata[symbol],
+            });
+        }
+        setValueBySplitter(this._metadata[symbol], key, value, this.splitter);
+    }
+}
+
+/**
+ * @description Assigns arbitrary metadata to a target using a string key
+ * @summary Decorator factory that stores a key/value pair in the central Metadata store for the provided class or member.
+ * @param {string} key The metadata key to associate with the target
+ * @param {*} value The metadata value to store under the given key
+ * @return A decorator that writes the metadata when applied
+ * @function metadata
+ * @category Decorators
+ */
+function metadata(key, value) {
+    return function metadata(model, prop, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    descriptor) {
+        Metadata.set(prop ? model.constructor : model, key, value);
+    };
+}
+/**
+ * @description Captures and stores a property's design type
+ * @summary Decorator factory that reads the reflected design:type for a property and registers it in the Metadata store under the properties map.
+ * @return A decorator that records the property's type metadata when applied
+ * @function prop
+ * @category Property Decorators
+ */
+function prop() {
+    return function prop(model, prop) {
+        const designType = Reflect.getOwnMetadata(DecorationKeys.DESIGN_TYPE, model, prop);
+        return metadata(`${DecorationKeys.PROPERTIES}.${prop}`, designType)(model, prop);
+    };
+}
+/**
+ * @description Decorator factory that applies multiple decorators to a single target
+ * @summary Creates a composite decorator that applies multiple decorators in sequence, correctly handling class, method, and property decorators.
+ * @param {Array<ClassDecorator | MethodDecorator | PropertyDecorator>} decorators - Array of decorators to apply
+ * @return {Function} A decorator function that applies all provided decorators to the target
+ * @function apply
+ * @mermaid
+ * sequenceDiagram
+ *   participant U as User Code
+ *   participant A as apply(...decorators)
+ *   participant D as Decorator
+ *   U->>A: get decorator(...decorators)
+ *   A->>U: returns (target, key?, desc?) => void
+ *   U->>A: invoke on target
+ *   loop for each decorator
+ *     A->>D: invoke appropriate decorator type
+ *   end
+ * @category Decorators
+ */
+function apply(...decorators) {
+    return (target, propertyKey, descriptor) => {
+        for (const decorator of decorators) {
+            if (target instanceof Function && !descriptor) {
+                decorator(target);
+                continue;
+            }
+            decorator(target, propertyKey, descriptor);
+        }
+    };
+}
+/**
+ * @description Creates a property metadata decorator
+ * @summary Convenience factory that combines metadata(key, value) and prop() to both set an arbitrary metadata key and record the property's design type.
+ * @param {string} key The metadata key to set for the property
+ * @param {*} value The metadata value to associate with the key
+ * @return A decorator that sets the metadata and captures the property's type
+ * @function propMetadata
+ * @category Property Decorators
+ */
+function propMetadata(key, value) {
+    return apply(metadata(key, value), prop());
+}
+/**
+ * @description Attaches a human-readable description to a class or member
+ * @summary Decorator factory that stores a textual description in the Metadata store under the appropriate description key for a class or its property.
+ * @param {string} desc The descriptive text to associate with the class or property
+ * @return A decorator that records the description when applied
+ * @function description
+ * @category Decorators
+ */
+function description(desc) {
+    return function description(original, prop, descriptor) {
+        return metadata([
+            DecorationKeys.DESCRIPTION,
+            prop ? prop.toString() : DecorationKeys.CLASS,
+        ].join(ObjectKeySplitter), desc)(original, prop, descriptor);
+    };
+}
+
+/**
+ * @description Root entry point for the decoration module
+ * @summary Aggregates and re-exports the public API of the decoration library, including core classes like {@link Decoration}, utility decorators, metadata helpers, and constants. This module is the primary import surface for consumers and exposes:
+ * - Core builder: {@link Decoration}
+ * - Decorator utilities: {@link module:decoration | decorators in ./decorators}
+ * - Metadata utilities: {@link Metadata}
+ * - Constants and enums: {@link DecorationKeys}, {@link DefaultFlavour}
+ *
+ * @module decoration
+ */
+/**
+ * @description Current version of the reflection package
+ * @summary Stores the semantic version number of the package
+ * @const VERSION
+ * @memberOf module:decoration
+ */
+const VERSION = "0.0.2";
+
+export { Decoration, DecorationKeys, DefaultFlavour, DefaultMetadata, Metadata, ObjectKeySplitter, VERSION, apply, description, metadata, prop, propMetadata };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"decoration.esm.cjs","sources":["../src/constants.ts","../src/decoration/Decoration.ts","../src/metadata/Metadata.ts","../src/decorators.ts","../src/index.ts"],"sourcesContent":["import { BasicMetadata } from \"./metadata/types\";\n\n/**\n * @description Default flavour identifier for the decorator system\n * @summary Defines the default flavour used by the Decoration class when no specific flavour is provided.\n * This constant is used throughout the library as the fallback flavour for decorators.\n * @const DefaultFlavour\n * @memberOf module:decoration\n */\nexport const DefaultFlavour = \"decaf\";\n\n/**\n * @description Character used to split nested metadata keys\n * @summary The delimiter used by the metadata store to traverse nested object paths when reading/writing values.\n * @const ObjectKeySplitter\n * @memberOf module:decoration\n */\nexport const ObjectKeySplitter = \".\";\n\n/**\n * @description Enum containing metadata keys used for reflection in the model system\n * @summary Defines the various Model keys used for reflection and metadata storage.\n * These keys are used throughout the library to store and retrieve metadata about models,\n * their properties, and their behavior.\n * @readonly\n * @enum {string}\n * @readonly\n * @memberOf module:decoration\n */\nexport enum DecorationKeys {\n  /** Storage key used on the constructor to mirror runtime metadata */\n  REFLECT = `__${DefaultFlavour}`,\n  /** Map of model property keys to their reflected design types */\n  PROPERTIES = \"properties\",\n  /** Key under which the model's constructor is stored */\n  CLASS = \"class\",\n  /** Container of human-friendly descriptions per class and property */\n  DESCRIPTION = \"description\",\n  /** Reflect metadata key for design time type of a property */\n  DESIGN_TYPE = \"design:type\",\n  /** Reflect metadata key for constructor parameter types */\n  DESIGN_PARAMS = \"design:paramtypes\",\n  /** Reflect metadata key for method return type */\n  DESIGN_RETURN = \"design:returntype\",\n}\n\n/**\n * @description Typedef for the default metadata object shape\n * @summary Describes the minimal structure persisted for a model before any metadata is recorded.\n * @template M\n * @typedef {object} DefaultMetadataType<M>\n * @property {Record<string, Constructor | undefined>} properties - Mapping of property names to their design types\n * @memberOf module:decoration\n */\n\n/**\n * @description Default metadata instance\n * @summary Concrete default metadata object used when initializing metadata for a model\n * @type {DefaultMetadataType<any>}\n * @const DefaultMetadata\n * @memberOf module:decoration\n */\nexport const DefaultMetadata: BasicMetadata<any> = {\n  [DecorationKeys.PROPERTIES]: [],\n} as unknown as BasicMetadata<any>;\n","import {\n  DecorationBuilderBuild,\n  DecorationBuilderEnd,\n  DecorationBuilderMid,\n  DecorationBuilderStart,\n  FlavourResolver,\n  IDecorationBuilder,\n} from \"./types\";\nimport { DefaultFlavour } from \"../constants\";\n\n/**\n * @description Default resolver that returns the current default flavour\n * @summary Resolves the flavour for a given target by always returning the library's DefaultFlavour value.\n * @param {object} target The target object being decorated\n * @return {string} The resolved flavour identifier\n * @function defaultFlavourResolver\n * @memberOf module:decoration\n */\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nfunction defaultFlavourResolver(target: object) {\n  return DefaultFlavour;\n}\n\n/**\n * @description Union type covering supported decorator kinds\n * @summary Represents any of the standard TypeScript decorator signatures (class, property, or method), enabling flexible registration and application within the Decoration system.\n * @template T\n * @typeDef DecoratorTypes\n * @memberOf module:decoration\n */\nexport type DecoratorTypes =\n  | ClassDecorator\n  | PropertyDecorator\n  | MethodDecorator;\n\n/**\n * @description Type definition for a decorator factory function\n * @summary Represents a function that accepts arbitrary arguments and returns a concrete decorator function to be applied to a target.\n * @template A\n * @typeDef DecoratorFactory\n * @memberOf module:decoration\n */\nexport type DecoratorFactory = (...args: any[]) => DecoratorTypes;\n\n/**\n * @description Argument bundle for a decorator factory\n * @summary Object form used to defer decorator creation, carrying both the factory function and its argument list to be invoked later during application.\n * @typeDef DecoratorFactoryArgs\n * @property {DecoratorFactory} decorator The factory function that produces a decorator when invoked\n * @property {any[]} [args] Optional list of arguments to pass to the decorator factory\n * @memberOf module:decoration\n */\nexport type DecoratorFactoryArgs = {\n  decorator: DecoratorFactory;\n  args?: any[];\n};\n\n/**\n * @description Union that represents either a ready-to-apply decorator or a factory with arguments\n * @summary Allows registering decorators in two forms: as direct decorator functions or as deferred factories paired with their argument lists for later instantiation.\n * @typeDef DecoratorData\n * @memberOf module:decoration\n */\nexport type DecoratorData = DecoratorTypes | DecoratorFactoryArgs;\n/**\n * @description A decorator management class that handles flavoured decorators\n * @summary The Decoration class provides a builder pattern for creating and managing decorators with different flavours.\n * It supports registering, extending, and applying decorators with context-aware flavour resolution.\n * The class implements a fluent interface for defining, extending, and applying decorators with different flavours,\n * allowing for framework-specific decorator implementations while maintaining a consistent API.\n * @template T Type of the decorator (ClassDecorator | PropertyDecorator | MethodDecorator)\n * @param {string} [flavour] Optional flavour parameter for the decorator context\n * @class\n * @example\n * ```typescript\n * // Create a new decoration for 'component' with default flavour\n * const componentDecorator = new Decoration()\n *   .for('component')\n *   .define(customComponentDecorator);\n *\n * // Create a flavoured decoration\n * const vueComponent = new Decoration('vue')\n *   .for('component')\n *   .define(vueComponentDecorator);\n *\n * // Apply the decoration\n * @componentDecorator\n * class MyComponent {}\n * ```\n * @mermaid\n * sequenceDiagram\n *   participant C as Client\n *   participant D as Decoration\n *   participant R as FlavourResolver\n *   participant F as DecoratorFactory\n *\n *   C->>D: new Decoration(flavour)\n *   C->>D: for(key)\n *   C->>D: define(decorators)\n *   D->>D: register(key, flavour, decorators)\n *   D->>F: decoratorFactory(key, flavour)\n *   F->>R: resolve(target)\n *   R-->>F: resolved flavour\n *   F->>F: apply decorators\n *   F-->>C: decorated target\n */\nexport class Decoration implements IDecorationBuilder {\n  /**\n   * @description Static map of registered decorators\n   * @summary Stores all registered decorators organized by key and flavour\n   */\n  private static decorators: Record<\n    string,\n    Record<\n      string,\n      {\n        decorators?: Set<DecoratorData>;\n        extras?: Set<DecoratorData>;\n      }\n    >\n  > = {};\n\n  /**\n   * @description Function to resolve flavour from a target\n   * @summary Resolver function that determines the appropriate flavour for a given target\n   */\n  private static flavourResolver: FlavourResolver = defaultFlavourResolver;\n\n  /**\n   * @description Set of decorators for the current context\n   */\n  private decorators?: Set<DecoratorData>;\n\n  /**\n   * @description Set of additional decorators\n   */\n  private extras?: Set<DecoratorData>;\n\n  /**\n   * @description Current decorator key\n   */\n  private key?: string;\n\n  constructor(private flavour: string = DefaultFlavour) {}\n\n  /**\n   * @description Sets the key for the decoration builder\n   * @summary Initializes a new decoration chain with the specified key\n   * @param {string} key The identifier for the decorator\n   * @return {DecorationBuilderMid} Builder instance for method chaining\n   */\n  for(key: string): DecorationBuilderMid {\n    this.key = key;\n    return this;\n  }\n\n  /**\n   * @description Adds decorators to the current context\n   * @summary Internal method to add decorators with addon support\n   * @param {boolean} [addon=false] Whether the decorators are addons\n   * @param decorators Array of decorators\n   * @return {this} Current instance for chaining\n   */\n  private decorate(\n    addon: boolean = false,\n    ...decorators: DecoratorData[]\n  ): this {\n    if (!this.key)\n      throw new Error(\"key must be provided before decorators can be added\");\n    if (\n      (!decorators || !decorators.length) &&\n      !addon &&\n      this.flavour !== DefaultFlavour\n    )\n      throw new Error(\n        \"Must provide overrides or addons to override or extend decaf's decorators\"\n      );\n    if (this.flavour === DefaultFlavour && addon)\n      throw new Error(\"Default flavour cannot be extended\");\n\n    this[addon ? \"extras\" : \"decorators\"] = new Set([\n      ...(this[addon ? \"extras\" : \"decorators\"] || new Set()).values(),\n      ...decorators,\n    ]);\n\n    return this;\n  }\n\n  /**\n   * @description Defines the base decorators\n   * @summary Sets the primary decorators for the current context\n   * @param decorators Decorators to define\n   * @return Builder instance for finishing the chain\n   */\n  define(\n    ...decorators: DecoratorData[]\n  ): DecorationBuilderEnd & DecorationBuilderBuild {\n    return this.decorate(false, ...decorators);\n  }\n\n  /**\n   * @description Extends existing decorators\n   * @summary Adds additional decorators to the current context\n   * @param decorators Additional decorators\n   * @return {DecorationBuilderBuild} Builder instance for building the decorator\n   */\n  extend(...decorators: DecoratorData[]): DecorationBuilderBuild {\n    return this.decorate(true, ...decorators);\n  }\n\n  /**\n   * @description Factory that creates a context-aware decorator for a key/flavour\n   * @summary Produces a decorator function bound to the provided key and flavour. The resulting decorator resolves the actual\n   * decorators to apply at invocation time based on the target's resolved flavour and the registered base and extra decorators.\n   * @param {string} key The decoration key used to look up registered decorators\n   * @param {string} [f=DefaultFlavour] Optional explicit flavour to bind the factory to\n   * @return {function(object, any, TypedPropertyDescriptor<any>): any} A decorator function that applies the resolved decorators\n   * @mermaid\n   * sequenceDiagram\n   *   participant U as User Code\n   *   participant B as Decoration (builder)\n   *   participant F as decoratorFactory(key, f)\n   *   participant R as flavourResolver\n   *   participant A as Applied Decorators\n   *   U->>B: define()/extend() and apply()\n   *   B->>F: create context decorator\n   *   F->>R: resolve(target)\n   *   R-->>F: flavour\n   *   F->>A: collect base + extras\n   *   loop each decorator\n   *     A->>U: invoke decorator(target, key?, desc?)\n   *   end\n   */\n  protected decoratorFactory(key: string, f: string = DefaultFlavour) {\n    function contextDecorator(\n      target: object,\n      propertyKey?: any,\n      descriptor?: TypedPropertyDescriptor<any>\n    ) {\n      const flavour = Decoration.flavourResolver(target);\n      const cache = Decoration.decorators[key];\n      let decorators;\n      const extras = cache[flavour]\n        ? cache[flavour].extras\n        : cache[DefaultFlavour].extras;\n      const extraArgs = [\n        ...((cache[DefaultFlavour] as any).extras\n          ? (cache[DefaultFlavour] as any).extras.values()\n          : []),\n      ].reduce((accum: Record<number, any>, e, i) => {\n        if (e.args) accum[i] = e.args;\n        return accum;\n      }, {});\n\n      if (\n        cache &&\n        cache[flavour] &&\n        cache[flavour].decorators &&\n        cache[flavour].decorators.size\n      ) {\n        decorators = cache[flavour].decorators;\n      } else {\n        decorators = cache[DefaultFlavour].decorators;\n      }\n\n      const decoratorArgs = [\n        ...(cache[DefaultFlavour] as any).decorators.values(),\n      ].reduce((accum: Record<number, any>, e, i) => {\n        if (e.args) accum[i] = e.args;\n        return accum;\n      }, {});\n\n      const toApply = [\n        ...(decorators ? decorators.values() : []),\n        ...(extras ? extras.values() : []),\n      ];\n\n      return toApply.reduce(\n        (_, d, i) => {\n          switch (typeof d) {\n            case \"object\": {\n              const { decorator, args } = d as DecoratorFactoryArgs;\n              const argz =\n                args || i < (decorators ? decorators.size : 0)\n                  ? decoratorArgs[i]\n                  : extraArgs[i - (decorators ? decorators.size : 0)] ||\n                    (decorators ? decoratorArgs[i - decorators.size] : []);\n\n              return (decorator(...(argz || [])) as any)(\n                target,\n                propertyKey,\n                descriptor\n              );\n            }\n            case \"function\":\n              return (d as any)(target, propertyKey, descriptor);\n            default:\n              throw new Error(`Unexpected decorator type: ${typeof d}`);\n          }\n        },\n        { target, propertyKey, descriptor }\n      );\n    }\n    Object.defineProperty(contextDecorator, \"name\", {\n      value: [f, key].join(\"_decorator_for_\"),\n      writable: false,\n    });\n    return contextDecorator;\n  }\n\n  /**\n   * @description Creates the final decorator function\n   * @summary Builds and returns the decorator factory function\n   * @return {function(any, any?, TypedPropertyDescriptor?): any} The generated decorator function\n   */\n  apply(): (\n    target: any,\n    propertyKey?: any,\n    descriptor?: TypedPropertyDescriptor<any>\n  ) => any {\n    if (!this.key)\n      throw new Error(\"No key provided for the decoration builder\");\n    Decoration.register(\n      this.key,\n      this.flavour,\n      this.decorators || new Set(),\n      this.extras\n    );\n    return this.decoratorFactory(this.key, this.flavour);\n  }\n\n  /**\n   * @description Registers decorators for a specific key and flavour\n   * @summary Internal method to store decorators in the static registry\n   * @param {string} key Decorator key\n   * @param {string} flavour Decorator flavour\n   * @param [decorators] Primary decorators\n   * @param [extras] Additional decorators\n   */\n  private static register(\n    key: string,\n    flavour: string,\n    decorators?: Set<DecoratorData>,\n    extras?: Set<DecoratorData>\n  ) {\n    if (!key) {\n      throw new Error(\"No key provided for the decoration builder\");\n    }\n    if (!decorators)\n      throw new Error(\"No decorators provided for the decoration builder\");\n    if (!flavour)\n      throw new Error(\"No flavour provided for the decoration builder\");\n\n    if (!Decoration.decorators[key]) Decoration.decorators[key] = {};\n    if (!Decoration.decorators[key][flavour])\n      Decoration.decorators[key][flavour] = {};\n    if (decorators) Decoration.decorators[key][flavour].decorators = decorators;\n    if (extras) Decoration.decorators[key][flavour].extras = extras;\n  }\n\n  /**\n   * @description Sets the global flavour resolver\n   * @summary Configures the function used to determine decorator flavours\n   * @param {FlavourResolver} resolver Function to resolve flavours\n   */\n  static setFlavourResolver(resolver: FlavourResolver) {\n    Decoration.flavourResolver = resolver;\n  }\n\n  /**\n   * @description Convenience static entry to start a decoration builder\n   * @summary Creates a new Decoration instance and initiates the builder chain with the provided key.\n   * @param {string} key The decoration key to configure\n   * @return {DecorationBuilderMid} A builder instance for chaining definitions\n   */\n  static for(key: string): DecorationBuilderMid {\n    return new Decoration().for(key);\n  }\n\n  /**\n   * @description Starts a builder for a specific flavour\n   * @summary Convenience method to begin a Decoration builder chain bound to the given flavour identifier, allowing registration of flavour-specific decorators.\n   * @param {string} flavour The flavour name to bind to the builder\n   * @return {DecorationBuilderStart} A builder start interface to continue configuration\n   */\n  static flavouredAs(flavour: string): DecorationBuilderStart {\n    return new Decoration(flavour);\n  }\n}\n","import { BasicMetadata, Constructor } from \"./types\";\nimport { DecorationKeys, ObjectKeySplitter } from \"../constants\";\nimport \"reflect-metadata\";\n\n/**\n * @description Retrieves a nested value from an object given a path\n * @summary Walks an object structure using a splitter-delimited path and returns the value at that location or undefined if any key is missing.\n * @param {Record<string, any>} obj The object to traverse\n * @param {string} path The path to the desired value (e.g., \"a.b.c\")\n * @param {string} [splitter=ObjectKeySplitter] The delimiter used to split the path\n * @return {*} The resolved value at the given path or undefined if not found\n * @function getValueBySplitter\n * @mermaid\n * sequenceDiagram\n *   participant C as Caller\n *   participant F as getValueBySplitter\n *   participant O as Object\n *   C->>F: (obj, path, splitter)\n *   F->>F: split path into keys\n *   loop for each key\n *     F->>O: access current[key]\n *     alt missing or nullish\n *       F-->>C: return undefined\n *     end\n *   end\n *   F-->>C: return final value\n * @memberOf module:decoration\n */\nfunction getValueBySplitter(\n  obj: Record<string, any>,\n  path: string,\n  splitter: string = ObjectKeySplitter\n): any {\n  const keys = path.split(splitter);\n  let current = obj;\n\n  for (const key of keys) {\n    if (\n      current === null ||\n      current === undefined ||\n      !Object.prototype.hasOwnProperty.call(current, key)\n    )\n      return undefined;\n    current = current[key];\n  }\n\n  return current;\n}\n\n/**\n * @description Sets a nested value on an object given a path\n * @summary Traverses or creates intermediate objects following a splitter-delimited path and assigns the provided value at the destination key.\n * @param {Record<string, any>} obj The object to mutate\n * @param {string} path The destination path (e.g., \"a.b.c\")\n * @param {*} value The value to set at the destination\n * @param {string} [splitter=ObjectKeySplitter] The delimiter used to split the path\n * @return {void}\n * @function setValueBySplitter\n * @mermaid\n * sequenceDiagram\n *   participant C as Caller\n *   participant F as setValueBySplitter\n *   participant O as Object\n *   C->>F: (obj, path, value, splitter)\n *   F->>F: split path into keys\n *   loop for each key\n *     alt key missing\n *       F->>O: create intermediate object\n *     else key exists\n *       F->>O: descend into existing object\n *     end\n *   end\n *   F-->>C: void\n * @memberOf module:decoration\n */\nfunction setValueBySplitter(\n  obj: Record<string, any>,\n  path: string,\n  value: any,\n  splitter = ObjectKeySplitter\n): void {\n  const keys = path.split(splitter).filter((k) => k.length > 0);\n  if (keys.length === 0) return;\n\n  let current: Record<any, any> = obj;\n\n  for (let i = 0; i < keys.length - 1; i++) {\n    const key = keys[i];\n    if (\n      current[key] === undefined ||\n      current[key] === null ||\n      typeof current[key] !== \"object\"\n    ) {\n      current[key] = {};\n    }\n    current = current[key];\n  }\n\n  const lastKey = keys[keys.length - 1];\n  current[lastKey] = value;\n}\n\n/**\n * @description Centralized runtime metadata store bound to constructors\n * @summary Provides utilities to read and write structured metadata for classes and their members, with optional mirroring onto the constructor via a well-known symbol key. Supports nested key paths using a configurable splitter and offers both instance and static APIs.\n * @template M The model type the metadata belongs to\n * @template META Extends BasicMetadata<M> representing the metadata structure\n * @class\n * @example\n * // Define and read metadata for a class\n * class User { name!: string }\n * Metadata.set(User, \"description.class\", \"A user model\");\n * Metadata.set(User, \"properties.name\", String);\n * const desc = Metadata.get(User, \"description.class\"); // \"A user model\"\n * const type = Metadata.type(User, \"name\"); // String\n * @mermaid\n * sequenceDiagram\n *   participant C as Constructor\n *   participant S as Metadata (static)\n *   C->>S: set(User, \"properties.name\", String)\n *   C->>S: get(User, \"properties.name\")\n *   S-->>C: String\n */\nexport class Metadata {\n  /**\n   * @description In-memory storage of metadata by constructor symbol\n   * @summary Maps a Symbol derived from the constructor to its metadata object, enabling efficient lookup.\n   */\n  private static _metadata: Record<symbol, any> = {};\n\n  /**\n   * @description Path delimiter for nested metadata keys\n   * @summary Used by get/set operations to navigate nested structures, defaults to ObjectKeySplitter.\n   */\n  static splitter = ObjectKeySplitter;\n  /**\n   * @description Symbol key used to mirror metadata on the constructor\n   * @summary When mirroring is enabled, the metadata object is defined on the constructor under this non-enumerable key.\n   */\n  static baseKey = DecorationKeys.REFLECT;\n  /**\n   * @description Controls whether metadata is mirrored onto the constructor\n   * @summary When true, the metadata object is defined on the constructor under the non-enumerable baseKey.\n   */\n  static mirror: boolean = true;\n\n  private constructor() {}\n\n  /**\n   * @description Lists known property keys for a model\n   * @summary Reads the metadata entry and returns the names of properties that have recorded type information.\n   * @param {Constructor} model The target constructor\n   * @return {string[]|undefined} Array of property names or undefined if no metadata exists\n   */\n  static properties(model: Constructor): string[] | undefined {\n    const meta = this.get(model);\n    if (!meta) return undefined;\n    return Object.keys(meta.properties);\n  }\n\n  /**\n   * @description Retrieves a human-readable description for a class or a property\n   * @summary Looks up the description stored under the metadata \"description\" map. If a property key is provided, returns the property's description; otherwise returns the class description.\n   * @template M\n   * @param {Constructor<M>} model The target constructor whose description is being retrieved\n   * @param {string} [prop] Optional property key for which to fetch the description\n   * @return {string|undefined} The description text if present, otherwise undefined\n   */\n  static description<M>(model: Constructor<M>, prop?: keyof M) {\n    return this.get(\n      model,\n      [DecorationKeys.DESCRIPTION, prop ? prop : DecorationKeys.CLASS].join(\n        ObjectKeySplitter\n      )\n    );\n  }\n\n  /**\n   * @description Retrieves the recorded design type for a property\n   * @summary Reads the metadata entry under \"properties.<prop>\" to return the constructor recorded for the given property name.\n   * @param {Constructor} model The target constructor\n   * @param {string} prop The property name whose type should be returned\n   * @return {Constructor|undefined} The constructor reference of the property type or undefined if not available\n   */\n  static type(model: Constructor, prop: string) {\n    return this.get(model, `${DecorationKeys.PROPERTIES}.${prop}`);\n  }\n\n  /**\n   * @description Retrieves metadata for a model or a specific key within it\n   * @summary When called with a constructor only, returns the entire metadata object associated with the model. When a key path is provided, returns the value stored at that nested key.\n   * @template M\n   * @template META\n   * @param {Constructor<M>} model The target constructor used to locate the metadata record\n   * @return {META|undefined} The metadata object, the value at the key path, or undefined if nothing exists\n   */\n  static get<M, META extends BasicMetadata<M> = BasicMetadata<M>>(\n    model: Constructor<M>\n  ): META | undefined;\n  /**\n   * @description Retrieves metadata for a model or a specific key within it\n   * @summary When called with a constructor only, returns the entire metadata object associated with the model. When a key path is provided, returns the value stored at that nested key.\n   * @template M\n   * @template META\n   * @param {Constructor<M>} model The target constructor used to locate the metadata record\n   * @param {string} key nested key path to fetch a specific value\n   * @return {META|*|undefined} The metadata object, the value at the key path, or undefined if nothing exists\n   */\n  static get(model: Constructor, key: string): any;\n  /**\n   * @description Retrieves metadata for a model or a specific key within it\n   * @summary When called with a constructor only, returns the entire metadata object associated with the model. When a key path is provided, returns the value stored at that nested key.\n   * @template M\n   * @template META\n   * @param {Constructor<M>} model The target constructor used to locate the metadata record\n   * @param {string} [key] Optional nested key path to fetch a specific value\n   * @return {META|*|undefined} The metadata object, the value at the key path, or undefined if nothing exists\n   */\n  static get(model: Constructor, key?: string) {\n    const symbol = Symbol.for(model.toString());\n    if (!this._metadata[symbol]) return undefined;\n    if (!key) return this._metadata[symbol];\n    return getValueBySplitter(this._metadata[symbol], key, this.splitter);\n  }\n\n  /**\n   * @description Writes a metadata value at a given nested key path\n   * @summary Ensures the metadata record exists for the constructor, mirrors it on the constructor when enabled, and sets the provided value on the nested key path using the configured splitter.\n   * @param {Constructor} model The target constructor to which the metadata belongs\n   * @param {string} key The nested key path at which to store the value\n   * @param {*} value The value to store in the metadata\n   * @return {void}\n   */\n  static set(model: Constructor, key: string, value: any) {\n    const symbol = Symbol.for(model.toString());\n    if (!this._metadata[symbol]) this._metadata[symbol] = {} as any;\n    if (\n      Metadata.mirror &&\n      !Object.prototype.hasOwnProperty.call(model, this.baseKey)\n    ) {\n      Object.defineProperty(model, this.baseKey, {\n        enumerable: false,\n        configurable: false,\n        writable: false,\n        value: this._metadata[symbol],\n      });\n    }\n    setValueBySplitter(this._metadata[symbol], key, value, this.splitter);\n  }\n}\n","import { Metadata } from \"./metadata/Metadata\";\nimport { DecorationKeys, ObjectKeySplitter } from \"./constants\";\n\n/**\n * @description Assigns arbitrary metadata to a target using a string key\n * @summary Decorator factory that stores a key/value pair in the central Metadata store for the provided class or member.\n * @param {string} key The metadata key to associate with the target\n * @param {*} value The metadata value to store under the given key\n * @return A decorator that writes the metadata when applied\n * @function metadata\n * @category Decorators\n */\nexport function metadata(key: string, value: any) {\n  return function metadata(\n    model: any,\n\n    prop?: any,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    descriptor?: PropertyDescriptor\n  ) {\n    Metadata.set(prop ? model.constructor : model, key, value);\n  };\n}\n\n/**\n * @description Captures and stores a property's design type\n * @summary Decorator factory that reads the reflected design:type for a property and registers it in the Metadata store under the properties map.\n * @return A decorator that records the property's type metadata when applied\n * @function prop\n * @category Property Decorators\n */\nexport function prop() {\n  return function prop(model: object, prop: any) {\n    const designType = Reflect.getOwnMetadata(\n      DecorationKeys.DESIGN_TYPE,\n      model,\n      prop\n    );\n    return metadata(`${DecorationKeys.PROPERTIES}.${prop}`, designType)(\n      model,\n      prop\n    );\n  };\n}\n\n/**\n * @description Decorator factory that applies multiple decorators to a single target\n * @summary Creates a composite decorator that applies multiple decorators in sequence, correctly handling class, method, and property decorators.\n * @param {Array<ClassDecorator | MethodDecorator | PropertyDecorator>} decorators - Array of decorators to apply\n * @return {Function} A decorator function that applies all provided decorators to the target\n * @function apply\n * @mermaid\n * sequenceDiagram\n *   participant U as User Code\n *   participant A as apply(...decorators)\n *   participant D as Decorator\n *   U->>A: get decorator(...decorators)\n *   A->>U: returns (target, key?, desc?) => void\n *   U->>A: invoke on target\n *   loop for each decorator\n *     A->>D: invoke appropriate decorator type\n *   end\n * @category Decorators\n */\nexport function apply(\n  ...decorators: Array<ClassDecorator | MethodDecorator | PropertyDecorator>\n) {\n  return (\n    target: object,\n    propertyKey?: string | symbol | unknown,\n    descriptor?: PropertyDescriptor\n  ) => {\n    for (const decorator of decorators) {\n      if (target instanceof Function && !descriptor) {\n        (decorator as ClassDecorator)(target);\n        continue;\n      }\n      (decorator as MethodDecorator | PropertyDecorator)(\n        target,\n        propertyKey as string | symbol,\n        descriptor as TypedPropertyDescriptor<unknown>\n      );\n    }\n  };\n}\n\n/**\n * @description Creates a property metadata decorator\n * @summary Convenience factory that combines metadata(key, value) and prop() to both set an arbitrary metadata key and record the property's design type.\n * @param {string} key The metadata key to set for the property\n * @param {*} value The metadata value to associate with the key\n * @return A decorator that sets the metadata and captures the property's type\n * @function propMetadata\n * @category Property Decorators\n */\nexport function propMetadata(key: string, value: any) {\n  return apply(metadata(key, value), prop());\n}\n\n/**\n * @description Attaches a human-readable description to a class or member\n * @summary Decorator factory that stores a textual description in the Metadata store under the appropriate description key for a class or its property.\n * @param {string} desc The descriptive text to associate with the class or property\n * @return A decorator that records the description when applied\n * @function description\n * @category Decorators\n */\nexport function description(desc: string) {\n  return function description(original: any, prop: any, descriptor?: any) {\n    return metadata(\n      [\n        DecorationKeys.DESCRIPTION,\n        prop ? prop.toString() : DecorationKeys.CLASS,\n      ].join(ObjectKeySplitter),\n      desc\n    )(original, prop, descriptor);\n  };\n}\n","/**\n * @description Root entry point for the decoration module\n * @summary Aggregates and re-exports the public API of the decoration library, including core classes like {@link Decoration}, utility decorators, metadata helpers, and constants. This module is the primary import surface for consumers and exposes:\n * - Core builder: {@link Decoration}\n * - Decorator utilities: {@link module:decoration | decorators in ./decorators}\n * - Metadata utilities: {@link Metadata}\n * - Constants and enums: {@link DecorationKeys}, {@link DefaultFlavour}\n *\n * @module decoration\n */\n\nexport * from \"./decoration\";\nexport * from \"./metadata\";\nexport * from \"./constants\";\nexport * from \"./decorators\";\n\n/**\n * @description Current version of the reflection package\n * @summary Stores the semantic version number of the package\n * @const VERSION\n * @memberOf module:decoration\n */\nexport const VERSION = \"##VERSION##\";\n"],"names":[],"mappings":"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"}