@decaf-ts/decoration 0.0.2

package/dist/decoration.cjs

@@ -0,0 +1,649 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('reflect-metadata')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'reflect-metadata'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.decoration = {}));
+})(this, (function (exports) { 'use strict';
+
+    /**
+     * @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
+     */
+    exports.DecorationKeys = void 0;
+    (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";
+    })(exports.DecorationKeys || (exports.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 = {
+        [exports.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 = exports.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, [exports.DecorationKeys.DESCRIPTION, prop ? prop : exports.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, `${exports.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(exports.DecorationKeys.DESIGN_TYPE, model, prop);
+            return metadata(`${exports.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([
+                exports.DecorationKeys.DESCRIPTION,
+                prop ? prop.toString() : exports.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";
+
+    exports.Decoration = Decoration;
+    exports.DefaultFlavour = DefaultFlavour;
+    exports.DefaultMetadata = DefaultMetadata;
+    exports.Metadata = Metadata;
+    exports.ObjectKeySplitter = ObjectKeySplitter;
+    exports.VERSION = VERSION;
+    exports.apply = apply;
+    exports.description = description;
+    exports.metadata = metadata;
+    exports.prop = prop;
+    exports.propMetadata = propMetadata;
+
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"decoration.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":["DecorationKeys"],"mappings":"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"}