@decaf-ts/decoration 0.0.2

package/lib/esm/decoration/Decoration.js

@@ -0,0 +1,266 @@
+import { DefaultFlavour } from "./../constants.js";
+/**
+ * @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
+ */
+export 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);
+    }
+}
+//# 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/esm/decoration/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Decoration";
+export * from "./types";

package/lib/esm/decoration/index.js

@@ -0,0 +1,3 @@
+export * from "./Decoration.js";
+export * from "./types.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZGVjb3JhdGlvbi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxnQ0FBNkI7QUFDN0IsMkJBQXdCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vRGVjb3JhdGlvblwiO1xuZXhwb3J0ICogZnJvbSBcIi4vdHlwZXNcIjtcbiJdfQ==

package/lib/esm/decoration/types.d.ts

@@ -0,0 +1,95 @@
+import { DecoratorData } from "./Decoration";
+/**
+ * @description Interface for the final stage of the decoration builder pattern
+ * @summary Represents the build stage of the decoration builder, providing the ability to apply
+ * the configured decorator to a target. This is the final stage in the builder chain.
+ *
+ * @interface DecorationBuilderBuild
+ */
+export interface DecorationBuilderBuild {
+    /**
+     * @description Creates and returns the decorator function
+     * @summary Finalizes the builder process and returns a decorator function that can be applied to a class,
+     * property, or method.
+     *
+     * @returns {function} A decorator function that can be applied to a target
+     */
+    apply(): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+}
+/**
+ * @description Interface for the extension stage of the decoration builder pattern
+ * @summary Represents the extension stage of the decoration builder, providing the ability to add
+ * additional decorators to the existing configuration.
+ *
+ * @interface DecorationBuilderEnd
+ * @memberOf module:decoration
+ */
+export interface DecorationBuilderEnd {
+    /**
+     * @description Adds additional decorators to the existing configuration
+     * @summary Extends the current decorator configuration with additional decorators.
+     * This is useful for adding behavior to existing decorators.
+     *
+     * @param {...(ClassDecorator|PropertyDecorator|MethodDecorator)} decorators - Additional decorators to add
+     * @returns {DecorationBuilderBuild} The build stage of the builder pattern
+     */
+    extend(...decorators: DecoratorData[]): DecorationBuilderBuild;
+}
+/**
+ * @description Interface for the middle stage of the decoration builder pattern
+ * @summary Represents the middle stage of the decoration builder, extending the end stage
+ * and providing the ability to define the primary decorators for the configuration.
+ *
+ * @interface DecorationBuilderMid
+ * @memberOf module:decoration
+ */
+export interface DecorationBuilderMid extends DecorationBuilderEnd {
+    /**
+     * @description Defines the primary decorators for the configuration
+     * @summary Sets the main decorators for the current context. This is typically
+     * called after specifying the key with the 'for' method.
+     */
+    define(...decorators: DecoratorData[]): DecorationBuilderEnd & DecorationBuilderBuild;
+}
+/**
+ * @description Interface for the starting stage of the decoration builder pattern
+ * @summary Represents the initial stage of the decoration builder, providing the entry point
+ * for the builder pattern by specifying the key for the decorator.
+ *
+ * @interface DecorationBuilderStart
+ * @memberOf module:decoration
+ */
+export interface DecorationBuilderStart {
+    /**
+     * @description Specifies the key for the decorator
+     * @summary Sets the identifier for the decorator, which is used to register and retrieve
+     * the decorator in the decoration registry.
+     *
+     * @param {string} id - The identifier for the decorator
+     * @return {DecorationBuilderMid} The middle stage of the builder pattern
+     */
+    for(id: string): DecorationBuilderMid;
+}
+/**
+ * @description Comprehensive interface for the complete decoration builder pattern
+ * @summary A unified interface that combines all stages of the decoration builder pattern,
+ * providing a complete API for creating, configuring, and applying decorators.
+ * This interface is implemented by the Decoration class.
+ *
+ * @interface IDecorationBuilder
+ * @memberOf module:decoration
+ */
+export interface IDecorationBuilder extends DecorationBuilderStart, DecorationBuilderMid, DecorationBuilderEnd, DecorationBuilderBuild {
+}
+/**
+ * @description Type definition for a function that resolves the flavour for a target
+ * @summary Defines a function type that determines the appropriate flavour for a given target object.
+ * This is used by the Decoration class to resolve which flavour of decorator to apply based on the target.
+ *
+ * @typedef {function(object): string} FlavourResolver
+ *
+ * @param {object} target - The target object to resolve the flavour for
+ * @return {string} The resolved flavour identifier
+ * @memberOf module:decoration
+ */
+export type FlavourResolver = (target: object) => string;

package/lib/esm/decoration/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/decorators.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @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
+ */
+export declare function metadata(key: string, value: any): (model: any, prop?: any, descriptor?: PropertyDescriptor) => void;
+/**
+ * @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
+ */
+export declare function prop(): (model: object, prop: any) => void;
+/**
+ * @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
+ */
+export declare function apply(...decorators: Array<ClassDecorator | MethodDecorator | PropertyDecorator>): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
+/**
+ * @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
+ */
+export declare function propMetadata(key: string, value: any): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
+/**
+ * @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
+ */
+export declare function description(desc: string): (original: any, prop: any, descriptor?: any) => void;

package/lib/esm/decorators.js

@@ -0,0 +1,90 @@
+import { Metadata } from "./metadata/Metadata.js";
+import { DecorationKeys, ObjectKeySplitter } from "./constants.js";
+/**
+ * @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
+ */
+export 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
+ */
+export function prop() {
+    return function prop(model, prop) {
+        const designType = Reflect.getOwnMetadata(DecorationKeys.DESIGN_TYPE, model, prop);
+        return metadata(`${DecorationKeys.PROPERTIES}.${prop}`, designType)(model, prop);
+    };
+}
+/**
+ * @description Decorator factory that applies multiple decorators to a single target
+ * @summary Creates a composite decorator that applies multiple decorators in sequence, correctly handling class, method, and property decorators.
+ * @param {Array<ClassDecorator | MethodDecorator | PropertyDecorator>} decorators - Array of decorators to apply
+ * @return {Function} A decorator function that applies all provided decorators to the target
+ * @function apply
+ * @mermaid
+ * sequenceDiagram
+ *   participant U as User Code
+ *   participant A as apply(...decorators)
+ *   participant D as Decorator
+ *   U->>A: get decorator(...decorators)
+ *   A->>U: returns (target, key?, desc?) => void
+ *   U->>A: invoke on target
+ *   loop for each decorator
+ *     A->>D: invoke appropriate decorator type
+ *   end
+ * @category Decorators
+ */
+export 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
+ */
+export 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
+ */
+export function description(desc) {
+    return function description(original, prop, descriptor) {
+        return metadata([
+            DecorationKeys.DESCRIPTION,
+            prop ? prop.toString() : DecorationKeys.CLASS,
+        ].join(ObjectKeySplitter), desc)(original, prop, descriptor);
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @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
+ */
+export * from "./decoration";
+export * from "./metadata";
+export * from "./constants";
+export * from "./decorators";
+/**
+ * @description Current version of the reflection package
+ * @summary Stores the semantic version number of the package
+ * @const VERSION
+ * @memberOf module:decoration
+ */
+export declare const VERSION = "0.0.2";

package/lib/esm/index.js

@@ -0,0 +1,22 @@
+/**
+ * @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
+ */
+export * from "./decoration/index.js";
+export * from "./metadata/index.js";
+export * from "./constants.js";
+export * from "./decorators.js";
+/**
+ * @description Current version of the reflection package
+ * @summary Stores the semantic version number of the package
+ * @const VERSION
+ * @memberOf module:decoration
+ */
+export const VERSION = "0.0.2";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7OztHQVNHO0FBRUgsc0NBQTZCO0FBQzdCLG9DQUEyQjtBQUMzQiwrQkFBNEI7QUFDNUIsZ0NBQTZCO0FBRTdCOzs7OztHQUtHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sT0FBTyxHQUFHLGFBQWEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGRlc2NyaXB0aW9uIFJvb3QgZW50cnkgcG9pbnQgZm9yIHRoZSBkZWNvcmF0aW9uIG1vZHVsZVxuICogQHN1bW1hcnkgQWdncmVnYXRlcyBhbmQgcmUtZXhwb3J0cyB0aGUgcHVibGljIEFQSSBvZiB0aGUgZGVjb3JhdGlvbiBsaWJyYXJ5LCBpbmNsdWRpbmcgY29yZSBjbGFzc2VzIGxpa2Uge0BsaW5rIERlY29yYXRpb259LCB1dGlsaXR5IGRlY29yYXRvcnMsIG1ldGFkYXRhIGhlbHBlcnMsIGFuZCBjb25zdGFudHMuIFRoaXMgbW9kdWxlIGlzIHRoZSBwcmltYXJ5IGltcG9ydCBzdXJmYWNlIGZvciBjb25zdW1lcnMgYW5kIGV4cG9zZXM6XG4gKiAtIENvcmUgYnVpbGRlcjoge0BsaW5rIERlY29yYXRpb259XG4gKiAtIERlY29yYXRvciB1dGlsaXRpZXM6IHtAbGluayBtb2R1bGU6ZGVjb3JhdGlvbiB8IGRlY29yYXRvcnMgaW4gLi9kZWNvcmF0b3JzfVxuICogLSBNZXRhZGF0YSB1dGlsaXRpZXM6IHtAbGluayBNZXRhZGF0YX1cbiAqIC0gQ29uc3RhbnRzIGFuZCBlbnVtczoge0BsaW5rIERlY29yYXRpb25LZXlzfSwge0BsaW5rIERlZmF1bHRGbGF2b3VyfVxuICpcbiAqIEBtb2R1bGUgZGVjb3JhdGlvblxuICovXG5cbmV4cG9ydCAqIGZyb20gXCIuL2RlY29yYXRpb25cIjtcbmV4cG9ydCAqIGZyb20gXCIuL21ldGFkYXRhXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jb25zdGFudHNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2RlY29yYXRvcnNcIjtcblxuLyoqXG4gKiBAZGVzY3JpcHRpb24gQ3VycmVudCB2ZXJzaW9uIG9mIHRoZSByZWZsZWN0aW9uIHBhY2thZ2VcbiAqIEBzdW1tYXJ5IFN0b3JlcyB0aGUgc2VtYW50aWMgdmVyc2lvbiBudW1iZXIgb2YgdGhlIHBhY2thZ2VcbiAqIEBjb25zdCBWRVJTSU9OXG4gKiBAbWVtYmVyT2YgbW9kdWxlOmRlY29yYXRpb25cbiAqL1xuZXhwb3J0IGNvbnN0IFZFUlNJT04gPSBcIiMjVkVSU0lPTiMjXCI7XG4iXX0=