@decaf-ts/decoration 0.0.2

package/lib/constants.cjs

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultMetadata = exports.DecorationKeys = exports.ObjectKeySplitter = exports.DefaultFlavour = void 0;
+/**
+ * @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
+ */
+exports.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
+ */
+exports.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 || (exports.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
+ */
+exports.DefaultMetadata = {
+    [DecorationKeys.PROPERTIES]: [],
+};
+//# sourceMappingURL=data:application/json;base64,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

package/lib/constants.d.ts

@@ -0,0 +1,58 @@
+import { BasicMetadata } from "./metadata/types";
+/**
+ * @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
+ */
+export declare 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
+ */
+export declare 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
+ */
+export declare enum DecorationKeys {
+    /** Storage key used on the constructor to mirror runtime metadata */
+    REFLECT = "__decaf",
+    /** Map of model property keys to their reflected design types */
+    PROPERTIES = "properties",
+    /** Key under which the model's constructor is stored */
+    CLASS = "class",
+    /** Container of human-friendly descriptions per class and property */
+    DESCRIPTION = "description",
+    /** Reflect metadata key for design time type of a property */
+    DESIGN_TYPE = "design:type",
+    /** Reflect metadata key for constructor parameter types */
+    DESIGN_PARAMS = "design:paramtypes",
+    /** Reflect metadata key for method return type */
+    DESIGN_RETURN = "design:returntype"
+}
+/**
+ * @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
+ */
+export declare const DefaultMetadata: BasicMetadata<any>;

package/lib/decoration/Decoration.cjs

@@ -0,0 +1,270 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Decoration = void 0;
+const constants_1 = require("./../constants.cjs");
+/**
+ * @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 constants_1.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 = constants_1.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 !== constants_1.DefaultFlavour)
+            throw new Error("Must provide overrides or addons to override or extend decaf's decorators");
+        if (this.flavour === constants_1.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 = constants_1.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[constants_1.DefaultFlavour].extras;
+            const extraArgs = [
+                ...(cache[constants_1.DefaultFlavour].extras
+                    ? cache[constants_1.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[constants_1.DefaultFlavour].decorators;
+            }
+            const decoratorArgs = [
+                ...cache[constants_1.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);
+    }
+}
+exports.Decoration = Decoration;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Decoration.js","sourceRoot":"","sources":["../../src/decoration/Decoration.ts"],"names":[],"mappings":"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","sourcesContent":["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"]}

package/lib/decoration/Decoration.d.ts

@@ -0,0 +1,196 @@
+import { DecorationBuilderBuild, DecorationBuilderEnd, DecorationBuilderMid, DecorationBuilderStart, FlavourResolver, IDecorationBuilder } from "./types";
+/**
+ * @description Union type covering supported decorator kinds
+ * @summary Represents any of the standard TypeScript decorator signatures (class, property, or method), enabling flexible registration and application within the Decoration system.
+ * @template T
+ * @typeDef DecoratorTypes
+ * @memberOf module:decoration
+ */
+export type DecoratorTypes = ClassDecorator | PropertyDecorator | MethodDecorator;
+/**
+ * @description Type definition for a decorator factory function
+ * @summary Represents a function that accepts arbitrary arguments and returns a concrete decorator function to be applied to a target.
+ * @template A
+ * @typeDef DecoratorFactory
+ * @memberOf module:decoration
+ */
+export type DecoratorFactory = (...args: any[]) => DecoratorTypes;
+/**
+ * @description Argument bundle for a decorator factory
+ * @summary Object form used to defer decorator creation, carrying both the factory function and its argument list to be invoked later during application.
+ * @typeDef DecoratorFactoryArgs
+ * @property {DecoratorFactory} decorator The factory function that produces a decorator when invoked
+ * @property {any[]} [args] Optional list of arguments to pass to the decorator factory
+ * @memberOf module:decoration
+ */
+export type DecoratorFactoryArgs = {
+    decorator: DecoratorFactory;
+    args?: any[];
+};
+/**
+ * @description Union that represents either a ready-to-apply decorator or a factory with arguments
+ * @summary Allows registering decorators in two forms: as direct decorator functions or as deferred factories paired with their argument lists for later instantiation.
+ * @typeDef DecoratorData
+ * @memberOf module:decoration
+ */
+export type DecoratorData = DecoratorTypes | DecoratorFactoryArgs;
+/**
+ * @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
+ */
+export declare class Decoration implements IDecorationBuilder {
+    private flavour;
+    /**
+     * @description Static map of registered decorators
+     * @summary Stores all registered decorators organized by key and flavour
+     */
+    private static decorators;
+    /**
+     * @description Function to resolve flavour from a target
+     * @summary Resolver function that determines the appropriate flavour for a given target
+     */
+    private static flavourResolver;
+    /**
+     * @description Set of decorators for the current context
+     */
+    private decorators?;
+    /**
+     * @description Set of additional decorators
+     */
+    private extras?;
+    /**
+     * @description Current decorator key
+     */
+    private key?;
+    constructor(flavour?: string);
+    /**
+     * @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: string): DecorationBuilderMid;
+    /**
+     * @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
+     */
+    private decorate;
+    /**
+     * @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: DecoratorData[]): DecorationBuilderEnd & DecorationBuilderBuild;
+    /**
+     * @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: DecoratorData[]): DecorationBuilderBuild;
+    /**
+     * @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
+     */
+    protected decoratorFactory(key: string, f?: string): (target: object, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => {
+        target: object;
+        propertyKey: any;
+        descriptor: TypedPropertyDescriptor<any> | undefined;
+    };
+    /**
+     * @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(): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+    /**
+     * @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
+     */
+    private static register;
+    /**
+     * @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: FlavourResolver): void;
+    /**
+     * @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: string): DecorationBuilderMid;
+    /**
+     * @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: string): DecorationBuilderStart;
+}