@adaas/a-utils 0.2.7 → 0.2.9

package/dist/browser/a-config.d.mts

@@ -0,0 +1,60 @@
+import { A_Container, A_Error, A_Component, A_Scope, A_TYPES__ConceptENVVariables, A_Feature } from '@adaas/a-concept';
+import { A_Polyfill } from './a-polyfill.mjs';
+import { f as A_Config } from './A-Logger.component-Be-LMV3I.mjs';
+export { g as A_CONSTANTS__CONFIG_ENV_VARIABLES, h as A_CONSTANTS__CONFIG_ENV_VARIABLES_ARRAY, i as A_TYPES__ConfigContainerConstructor, j as A_TYPES__ConfigENVVariables, k as A_TYPES__ConfigFeature } from './A-Logger.component-Be-LMV3I.mjs';
+import './a-execution.mjs';
+
+declare class A_ConfigLoader extends A_Container {
+    private reader;
+    prepare(polyfill: A_Polyfill): Promise<void>;
+}
+
+declare class A_ConfigError extends A_Error {
+    static readonly InitializationError = "A-Config Initialization Error";
+}
+
+/**
+ * Config Reader
+ */
+declare class ConfigReader extends A_Component {
+    protected polyfill: A_Polyfill;
+    protected DEFAULT_ALLOWED_TO_READ_PROPERTIES: ("A_CONCEPT_NAME" | "A_CONCEPT_ROOT_SCOPE" | "A_CONCEPT_ENVIRONMENT" | "A_CONCEPT_RUNTIME_ENVIRONMENT" | "A_CONCEPT_ROOT_FOLDER" | "A_ERROR_DEFAULT_DESCRIPTION")[];
+    constructor(polyfill: A_Polyfill);
+    attachContext(container: A_Container, context: A_Scope, config?: A_Config<any>): Promise<void>;
+    initialize(config: A_Config): Promise<void>;
+    /**
+     * Get the configuration property by Name
+     * @param property
+     */
+    resolve<_ReturnType = any>(property: string): _ReturnType;
+    /**
+     * This method reads the configuration and sets the values to the context
+     *
+     * @returns
+     */
+    read<T extends string>(variables?: Array<T>): Promise<Record<T, any>>;
+}
+
+declare class ENVConfigReader extends ConfigReader {
+    readEnvFile(config: A_Config<A_TYPES__ConceptENVVariables>, polyfill: A_Polyfill, feature: A_Feature): Promise<void>;
+    /**
+     * Get the configuration property Name
+     * @param property
+     */
+    getConfigurationProperty_ENV_Alias(property: string): string;
+    resolve<_ReturnType = any>(property: string): _ReturnType;
+    read<T extends string>(variables?: Array<T>): Promise<Record<T, any>>;
+}
+
+declare class FileConfigReader extends ConfigReader {
+    private FileData;
+    /**
+     * Get the configuration property Name
+     * @param property
+     */
+    getConfigurationProperty_File_Alias(property: string): string;
+    resolve<_ReturnType = any>(property: string): _ReturnType;
+    read<T extends string>(variables?: Array<T>): Promise<Record<T, any>>;
+}
+
+export { A_Config, A_ConfigError, A_ConfigLoader, ConfigReader, ENVConfigReader, FileConfigReader };

package/dist/browser/a-config.mjs

@@ -0,0 +1,6 @@
+export { A_CONSTANTS__CONFIG_ENV_VARIABLES, A_CONSTANTS__CONFIG_ENV_VARIABLES_ARRAY, A_Config, A_ConfigError, A_ConfigLoader, A_TYPES__ConfigFeature, ConfigReader, ENVConfigReader, FileConfigReader } from './chunk-ECSGFDRQ.mjs';
+import './chunk-J6CLHXFQ.mjs';
+import './chunk-TQ5UON22.mjs';
+import './chunk-EQQGB2QZ.mjs';
+//# sourceMappingURL=a-config.mjs.map
+//# sourceMappingURL=a-config.mjs.map

package/dist/browser/a-config.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"a-config.mjs"}

package/dist/browser/a-execution.d.mts

@@ -0,0 +1,17 @@
+import { A_Fragment, A_Meta, A_TYPES__Fragment_Serialized } from '@adaas/a-concept';
+
+declare class A_ExecutionContext<_MetaType extends Record<string, any> = Record<string, any>, _SerializedType extends Record<string, any> = Record<string, any>> extends A_Fragment {
+    protected _meta: A_Meta<_MetaType, _SerializedType>;
+    constructor(name: string, defaults?: Partial<_MetaType>);
+    [Symbol.iterator](): Iterator<[keyof _MetaType, _MetaType[keyof _MetaType]]>;
+    get meta(): A_Meta<_MetaType>;
+    get<K extends keyof _MetaType>(key: K): _MetaType[K] | undefined;
+    set<K extends keyof _MetaType>(key: K, value: _MetaType[K]): this;
+    has(key: keyof _MetaType): boolean;
+    drop(key: keyof _MetaType): void;
+    clear(): this;
+    toRaw(): _SerializedType;
+    toJSON(): A_TYPES__Fragment_Serialized;
+}
+
+export { A_ExecutionContext };

package/dist/browser/a-execution.mjs

@@ -0,0 +1,4 @@
+export { A_ExecutionContext } from './chunk-TQ5UON22.mjs';
+import './chunk-EQQGB2QZ.mjs';
+//# sourceMappingURL=a-execution.mjs.map
+//# sourceMappingURL=a-execution.mjs.map

package/dist/browser/a-execution.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"a-execution.mjs"}

package/dist/browser/a-logger.d.mts

@@ -0,0 +1,107 @@
+export { A as A_Logger, a as A_LoggerColorName, b as A_LoggerEnvVariables, c as A_LoggerEnvVariablesArray, d as A_LoggerEnvVariablesType, e as A_LoggerLevel } from './A-Logger.component-Be-LMV3I.mjs';
+import '@adaas/a-concept';
+import './a-execution.mjs';
+
+/**
+ * A-Logger Constants
+ *
+ * Configuration constants and default values for the A_Logger component
+ */
+/**
+ * Default scope length for consistent message alignment
+ */
+declare const A_LOGGER_DEFAULT_SCOPE_LENGTH = 20;
+/**
+ * Default log level when none is specified
+ */
+declare const A_LOGGER_DEFAULT_LEVEL = "all";
+/**
+ * Terminal color codes mapping
+ */
+declare const A_LOGGER_COLORS: {
+    readonly red: "31";
+    readonly yellow: "33";
+    readonly green: "32";
+    readonly blue: "34";
+    readonly cyan: "36";
+    readonly magenta: "35";
+    readonly gray: "90";
+    readonly brightBlue: "94";
+    readonly brightCyan: "96";
+    readonly brightMagenta: "95";
+    readonly darkGray: "30";
+    readonly lightGray: "37";
+    readonly indigo: "38;5;54";
+    readonly violet: "38;5;93";
+    readonly purple: "38;5;129";
+    readonly lavender: "38;5;183";
+    readonly skyBlue: "38;5;117";
+    readonly steelBlue: "38;5;67";
+    readonly slateBlue: "38;5;62";
+    readonly deepBlue: "38;5;18";
+    readonly lightBlue: "38;5;153";
+    readonly periwinkle: "38;5;111";
+    readonly cornflower: "38;5;69";
+    readonly powder: "38;5;152";
+    readonly charcoal: "38;5;236";
+    readonly silver: "38;5;250";
+    readonly smoke: "38;5;244";
+    readonly slate: "38;5;240";
+};
+/**
+ * Safe colors for random selection - grey-blue-violet palette
+ * Excludes system colors (red, yellow, green) to avoid confusion with warnings/errors
+ */
+declare const A_LOGGER_SAFE_RANDOM_COLORS: readonly ["blue", "cyan", "magenta", "gray", "brightBlue", "brightCyan", "brightMagenta", "darkGray", "lightGray", "indigo", "violet", "purple", "lavender", "skyBlue", "steelBlue", "slateBlue", "deepBlue", "lightBlue", "periwinkle", "cornflower", "powder", "charcoal", "silver", "smoke", "slate"];
+/**
+ * ANSI escape codes
+ */
+declare const A_LOGGER_ANSI: {
+    readonly RESET: "\u001B[0m";
+    readonly PREFIX: "\u001B[";
+    readonly SUFFIX: "m";
+};
+/**
+ * Timestamp format configuration
+ */
+declare const A_LOGGER_TIME_FORMAT: {
+    readonly MINUTES_PAD: 2;
+    readonly SECONDS_PAD: 2;
+    readonly MILLISECONDS_PAD: 3;
+    readonly SEPARATOR: ":";
+};
+/**
+ * Log message structure constants
+ */
+declare const A_LOGGER_FORMAT: {
+    readonly SCOPE_OPEN: "[";
+    readonly SCOPE_CLOSE: "]";
+    readonly TIME_OPEN: "|";
+    readonly TIME_CLOSE: "|";
+    readonly SEPARATOR: "-------------------------------";
+    readonly INDENT_BASE: 3;
+    readonly PIPE: "| ";
+};
+/**
+ * Environment variable keys
+ */
+/**
+ * Terminal width configuration
+ */
+declare const A_LOGGER_TERMINAL: {
+    readonly DEFAULT_WIDTH: 80;
+    readonly MIN_WIDTH: 40;
+    readonly MAX_LINE_LENGTH_RATIO: 0.8;
+    readonly BROWSER_DEFAULT_WIDTH: 120;
+};
+/**
+ * Environment variable keys
+ */
+declare const A_LOGGER_ENV_KEYS: {
+    readonly LOG_LEVEL: "A_LOGGER_LEVEL";
+    readonly DEFAULT_SCOPE_LENGTH: "A_LOGGER_DEFAULT_SCOPE_LENGTH";
+    readonly DEFAULT_SCOPE_COLOR: "A_LOGGER_DEFAULT_SCOPE_COLOR";
+    readonly DEFAULT_LOG_COLOR: "A_LOGGER_DEFAULT_LOG_COLOR";
+};
+
+export { A_LOGGER_ANSI, A_LOGGER_COLORS, A_LOGGER_DEFAULT_LEVEL, A_LOGGER_DEFAULT_SCOPE_LENGTH, A_LOGGER_ENV_KEYS, A_LOGGER_FORMAT, A_LOGGER_SAFE_RANDOM_COLORS, A_LOGGER_TERMINAL, A_LOGGER_TIME_FORMAT };

package/dist/browser/a-logger.mjs

@@ -0,0 +1,7 @@
+export { A_LOGGER_ANSI, A_LOGGER_COLORS, A_LOGGER_DEFAULT_LEVEL, A_LOGGER_DEFAULT_SCOPE_LENGTH, A_LOGGER_ENV_KEYS, A_LOGGER_FORMAT, A_LOGGER_SAFE_RANDOM_COLORS, A_LOGGER_TERMINAL, A_LOGGER_TIME_FORMAT, A_Logger, A_LoggerEnvVariables, A_LoggerEnvVariablesArray } from './chunk-TK5UEYMZ.mjs';
+import './chunk-ECSGFDRQ.mjs';
+import './chunk-J6CLHXFQ.mjs';
+import './chunk-TQ5UON22.mjs';
+import './chunk-EQQGB2QZ.mjs';
+//# sourceMappingURL=a-logger.mjs.map
+//# sourceMappingURL=a-logger.mjs.map

package/dist/browser/a-logger.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"a-logger.mjs"}

package/dist/browser/a-manifest.d.mts

@@ -0,0 +1,111 @@
+import { A_Component, A_TYPES__Component_Constructor, A_TYPES__Entity_Constructor, A_TYPES__Fragment_Constructor, A_TYPES__Container_Constructor, A_Fragment, A_Error } from '@adaas/a-concept';
+
+type A_UTILS_TYPES__Manifest_Init = Array<A_UTILS_TYPES__Manifest_ComponentLevelConfig>;
+type A_UTILS_TYPES__Manifest_ComponentLevelConfig<T extends A_Component = A_Component> = {
+    /**
+     * Component constructor
+     */
+    component: A_TYPES__Component_Constructor<T>;
+    /**
+     * Method level configurations for the component
+     */
+    methods?: Array<A_UTILS_TYPES__Manifest_MethodLevelConfig<T>>;
+} & Partial<A_UTILS_TYPES__Manifest_Rules>;
+type A_UTILS_TYPES__Manifest_MethodLevelConfig<T extends A_Component = A_Component> = {
+    /**
+     * Method name from the component provided
+     */
+    method: string | RegExp;
+} & Partial<A_UTILS_TYPES__Manifest_Rules>;
+type A_UTILS_TYPES__Manifest_Rules = {
+    /**
+     * A list of entities to which a component is applied
+     *
+     * By default is for all
+     */
+    apply: Array<A_UTILS_TYPES__Manifest_AllowedComponents> | RegExp;
+    /**
+     * A list of entities to which a component is excluded
+     */
+    exclude: Array<A_UTILS_TYPES__Manifest_AllowedComponents> | RegExp;
+};
+type A_UTILS_TYPES__Manifest_AllowedComponents = A_TYPES__Component_Constructor | A_TYPES__Entity_Constructor | A_TYPES__Fragment_Constructor | A_TYPES__Container_Constructor;
+interface A_UTILS_TYPES__ManifestRule {
+    componentRegex: RegExp;
+    methodRegex: RegExp;
+    applyRegex?: RegExp;
+    excludeRegex?: RegExp;
+}
+interface A_UTILS_TYPES__ManifestQuery {
+    component: A_TYPES__Component_Constructor;
+    method: string;
+    target: A_UTILS_TYPES__Manifest_AllowedComponents;
+}
+
+/**
+ * Fluent API for checking manifest permissions
+ */
+declare class A_ManifestChecker {
+    private manifest;
+    private component;
+    private method;
+    private checkExclusion;
+    constructor(manifest: A_Manifest, component: A_TYPES__Component_Constructor, method: string, checkExclusion?: boolean);
+    for(target: A_UTILS_TYPES__Manifest_AllowedComponents): boolean;
+}
+
+declare class A_Manifest extends A_Fragment {
+    private rules;
+    /**
+     * A-Manifest is a configuration set that allows to include or exclude component application for the particular methods.
+     *
+     * For example, if A-Scope provides polymorphic A-Component that applies for All A-Entities in it but you have another component that should be used for only One particular Entity, you can use A-Manifest to specify this behavior.
+     *
+     *
+     * By default if Component is provided in the scope - it applies for all entities in it. However, if you want to exclude some entities or include only some entities for the particular component - you can use A-Manifest to define this behavior.
+     *
+     * @param config - Array of component configurations
+     */
+    constructor(config?: A_UTILS_TYPES__Manifest_Init);
+    /**
+     * Should convert received configuration into internal Regexp applicable for internal storage
+     */
+    protected prepare(config: A_UTILS_TYPES__Manifest_Init): void;
+    /**
+     * Process a single configuration item and convert it to internal rules
+     */
+    private processConfigItem;
+    /**
+     * Convert a constructor to a regex pattern
+     */
+    private constructorToRegex;
+    /**
+     * Convert a method name or regex to a regex pattern
+     */
+    private methodToRegex;
+    /**
+     * Convert allowed components array or regex to a single regex
+     */
+    private allowedComponentsToRegex;
+    /**
+     * Escape special regex characters in a string
+     */
+    private escapeRegex;
+    protected configItemToRegexp(item: A_TYPES__Component_Constructor): RegExp;
+    protected ID(component: A_TYPES__Component_Constructor, method: string): string;
+    /**
+     * Check if a component and method combination is allowed for a target
+     */
+    isAllowed<T extends A_Component>(ctor: T | A_TYPES__Component_Constructor<T>, method: string): A_ManifestChecker;
+    /**
+     * Internal method to check if access is allowed
+     */
+    internal_checkAccess(query: A_UTILS_TYPES__ManifestQuery): boolean;
+    isExcluded<T extends A_Component>(ctor: T | A_TYPES__Component_Constructor<T>, method: string): A_ManifestChecker;
+}
+
+declare class A_ManifestError extends A_Error {
+    static readonly ManifestInitializationError = "A-Manifest Initialization Error";
+}
+
+export { A_Manifest, A_ManifestChecker, A_ManifestError, type A_UTILS_TYPES__ManifestQuery, type A_UTILS_TYPES__ManifestRule, type A_UTILS_TYPES__Manifest_AllowedComponents, type A_UTILS_TYPES__Manifest_ComponentLevelConfig, type A_UTILS_TYPES__Manifest_Init, type A_UTILS_TYPES__Manifest_MethodLevelConfig, type A_UTILS_TYPES__Manifest_Rules };

package/dist/browser/a-manifest.mjs

@@ -0,0 +1,176 @@
+import { __decorateClass } from './chunk-EQQGB2QZ.mjs';
+import { A_Error, A_Fragment, A_TypeGuards } from '@adaas/a-concept';
+import { A_Frame } from '@adaas/a-frame';
+
+var A_ManifestError = class extends A_Error {
+};
+A_ManifestError.ManifestInitializationError = "A-Manifest Initialization Error";
+
+// src/lib/A-Manifest/classes/A-ManifestChecker.class.ts
+var A_ManifestChecker = class {
+  constructor(manifest, component, method, checkExclusion = false) {
+    this.manifest = manifest;
+    this.component = component;
+    this.method = method;
+    this.checkExclusion = checkExclusion;
+  }
+  for(target) {
+    const result = this.manifest.internal_checkAccess({
+      component: this.component,
+      method: this.method,
+      target
+    });
+    return this.checkExclusion ? !result : result;
+  }
+};
+var A_Manifest = class extends A_Fragment {
+  /**
+   * A-Manifest is a configuration set that allows to include or exclude component application for the particular methods.
+   *
+   * For example, if A-Scope provides polymorphic A-Component that applies for All A-Entities in it but you have another component that should be used for only One particular Entity, you can use A-Manifest to specify this behavior.
+   * 
+   * 
+   * By default if Component is provided in the scope - it applies for all entities in it. However, if you want to exclude some entities or include only some entities for the particular component - you can use A-Manifest to define this behavior.
+   * 
+   * @param config - Array of component configurations
+   */
+  constructor(config = []) {
+    super({
+      name: "A-Manifest"
+    });
+    this.rules = [];
+    this.prepare(config);
+  }
+  /**
+   * Should convert received configuration into internal Regexp applicable for internal storage
+   */
+  prepare(config) {
+    if (!A_TypeGuards.isArray(config))
+      throw new A_ManifestError(
+        A_ManifestError.ManifestInitializationError,
+        `A-Manifest configuration should be an array of configurations`
+      );
+    for (const item of config) {
+      this.processConfigItem(item);
+    }
+  }
+  /**
+   * Process a single configuration item and convert it to internal rules
+   */
+  processConfigItem(item) {
+    if (!A_TypeGuards.isComponentConstructor(item.component))
+      throw new A_ManifestError(
+        A_ManifestError.ManifestInitializationError,
+        `A-Manifest configuration item should be a A-Component constructor`
+      );
+    const componentRegex = this.constructorToRegex(item.component);
+    if (item.apply || item.exclude) {
+      const methodRegex = /.*/;
+      this.rules.push({
+        componentRegex,
+        methodRegex,
+        applyRegex: item.apply ? this.allowedComponentsToRegex(item.apply) : void 0,
+        excludeRegex: item.exclude ? this.allowedComponentsToRegex(item.exclude) : void 0
+      });
+    }
+    if (item.methods && item.methods.length > 0) {
+      for (const methodConfig of item.methods) {
+        const methodRegex = this.methodToRegex(methodConfig.method);
+        this.rules.push({
+          componentRegex,
+          methodRegex,
+          applyRegex: methodConfig.apply ? this.allowedComponentsToRegex(methodConfig.apply) : void 0,
+          excludeRegex: methodConfig.exclude ? this.allowedComponentsToRegex(methodConfig.exclude) : void 0
+        });
+      }
+    }
+  }
+  /**
+   * Convert a constructor to a regex pattern
+   */
+  constructorToRegex(ctor) {
+    return new RegExp(`^${this.escapeRegex(ctor.name)}$`);
+  }
+  /**
+   * Convert a method name or regex to a regex pattern
+   */
+  methodToRegex(method) {
+    if (method instanceof RegExp) {
+      return method;
+    }
+    return new RegExp(`^${this.escapeRegex(method)}$`);
+  }
+  /**
+   * Convert allowed components array or regex to a single regex
+   */
+  allowedComponentsToRegex(components) {
+    if (components instanceof RegExp) {
+      return components;
+    }
+    const patterns = components.map((ctor) => this.escapeRegex(ctor.name));
+    return new RegExp(`^(${patterns.join("|")})$`);
+  }
+  /**
+   * Escape special regex characters in a string
+   */
+  escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  configItemToRegexp(item) {
+    return this.constructorToRegex(item);
+  }
+  ID(component, method) {
+    return `${component.name}.${method}`;
+  }
+  /**
+   * Check if a component and method combination is allowed for a target
+   */
+  isAllowed(ctor, method) {
+    const componentCtor = typeof ctor === "function" ? ctor : ctor.constructor;
+    return new A_ManifestChecker(this, componentCtor, method);
+  }
+  /**
+   * Internal method to check if access is allowed
+   */
+  internal_checkAccess(query) {
+    const componentName = query.component.name;
+    const methodName = query.method;
+    const targetName = query.target.name;
+    const matchingRules = this.rules.filter(
+      (rule) => rule.componentRegex.test(componentName) && rule.methodRegex.test(methodName)
+    ).sort((a, b) => {
+      const aIsGeneral = a.methodRegex.source === ".*";
+      const bIsGeneral = b.methodRegex.source === ".*";
+      if (aIsGeneral && !bIsGeneral) return 1;
+      if (!aIsGeneral && bIsGeneral) return -1;
+      return 0;
+    });
+    if (matchingRules.length === 0) {
+      return true;
+    }
+    for (const rule of matchingRules) {
+      if (rule.excludeRegex && rule.excludeRegex.test(targetName)) {
+        return false;
+      }
+      if (rule.applyRegex) {
+        return rule.applyRegex.test(targetName);
+      }
+    }
+    return true;
+  }
+  isExcluded(ctor, method) {
+    const componentCtor = typeof ctor === "function" ? ctor : ctor.constructor;
+    return new A_ManifestChecker(this, componentCtor, method, true);
+  }
+};
+A_Manifest = __decorateClass([
+  A_Frame.Fragment({
+    namespace: "A-Utils",
+    name: "A-Manifest",
+    description: "A-Manifest is a configuration fragment that allows to include or exclude component application for particular methods. It provides fine-grained control over which components are applied to which targets and methods within the application, enabling flexible and dynamic behavior based on defined rules."
+  })
+], A_Manifest);
+
+export { A_Manifest, A_ManifestChecker, A_ManifestError };
+//# sourceMappingURL=a-manifest.mjs.map
+//# sourceMappingURL=a-manifest.mjs.map

package/dist/browser/a-manifest.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/A-Manifest/A-Manifest.error.ts","../../src/lib/A-Manifest/classes/A-ManifestChecker.class.ts","../../src/lib/A-Manifest/A-Manifest.context.ts"],"names":[],"mappings":"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","file":"a-manifest.mjs","sourcesContent":["import { A_Error } from \"@adaas/a-concept\";\n\nexport class A_ManifestError extends A_Error {\n\n    static readonly ManifestInitializationError = 'A-Manifest Initialization Error';\n\n}\n","import { A_TYPES__Component_Constructor } from \"@adaas/a-concept\";\nimport { A_Manifest } from \"../A-Manifest.context\";\nimport { A_UTILS_TYPES__Manifest_AllowedComponents } from \"../A-Manifest.types\";\n\n/**\n * Fluent API for checking manifest permissions\n */\nexport class A_ManifestChecker {\n    constructor(\n        private manifest: A_Manifest,\n        private component: A_TYPES__Component_Constructor,\n        private method: string,\n        private checkExclusion: boolean = false\n    ) {}\n\n    for(target: A_UTILS_TYPES__Manifest_AllowedComponents): boolean {\n        const result = this.manifest.internal_checkAccess({\n            component: this.component,\n            method: this.method,\n            target: target\n        });\n\n        return this.checkExclusion ? !result : result;\n    }\n}","import { A_Component, A_Fragment, A_TypeGuards, A_TYPES__Component_Constructor } from \"@adaas/a-concept\";\nimport { A_UTILS_TYPES__Manifest_Init, A_UTILS_TYPES__Manifest_ComponentLevelConfig, A_UTILS_TYPES__Manifest_AllowedComponents, A_UTILS_TYPES__ManifestRule, A_UTILS_TYPES__ManifestQuery } from \"./A-Manifest.types\";\nimport { A_ManifestError } from \"./A-Manifest.error\";\nimport { A_ManifestChecker } from \"./classes/A-ManifestChecker.class\";\nimport { A_Frame } from \"@adaas/a-frame\";\n\n\n\n\n\n@A_Frame.Fragment({\n    namespace: 'A-Utils',\n    name: 'A-Manifest',\n    description: 'A-Manifest is a configuration fragment that allows to include or exclude component application for particular methods. It provides fine-grained control over which components are applied to which targets and methods within the application, enabling flexible and dynamic behavior based on defined rules.'\n})\nexport class A_Manifest extends A_Fragment {\n\n    private rules: A_UTILS_TYPES__ManifestRule[] = [];\n\n    /**\n     * A-Manifest is a configuration set that allows to include or exclude component application for the particular methods.\n     *\n     * For example, if A-Scope provides polymorphic A-Component that applies for All A-Entities in it but you have another component that should be used for only One particular Entity, you can use A-Manifest to specify this behavior.\n     * \n     * \n     * By default if Component is provided in the scope - it applies for all entities in it. However, if you want to exclude some entities or include only some entities for the particular component - you can use A-Manifest to define this behavior.\n     * \n     * @param config - Array of component configurations\n     */\n    constructor(config: A_UTILS_TYPES__Manifest_Init = []) {\n        super({\n            name: 'A-Manifest',\n        });\n\n        this.prepare(config);\n    }\n\n\n    /**\n     * Should convert received configuration into internal Regexp applicable for internal storage\n     */\n    protected prepare(config: A_UTILS_TYPES__Manifest_Init) {\n        if (!A_TypeGuards.isArray(config))\n            throw new A_ManifestError(\n                A_ManifestError.ManifestInitializationError,\n                `A-Manifest configuration should be an array of configurations`\n            );\n\n        for (const item of config) {\n            this.processConfigItem(item);\n        }\n    }\n\n    /**\n     * Process a single configuration item and convert it to internal rules\n     */\n    private processConfigItem(item: A_UTILS_TYPES__Manifest_ComponentLevelConfig) {\n        if (!A_TypeGuards.isComponentConstructor(item.component))\n            throw new A_ManifestError(\n                A_ManifestError.ManifestInitializationError,\n                `A-Manifest configuration item should be a A-Component constructor`\n            );\n\n        const componentRegex = this.constructorToRegex(item.component);\n\n        // Always add component-level rule first (applies to all methods)\n        if (item.apply || item.exclude) {\n            const methodRegex = /.*/; // Match all methods\n\n            this.rules.push({\n                componentRegex,\n                methodRegex,\n                applyRegex: item.apply ? this.allowedComponentsToRegex(item.apply) : undefined,\n                excludeRegex: item.exclude ? this.allowedComponentsToRegex(item.exclude) : undefined,\n            });\n        }\n\n        // Then add method-level configurations (these will override component-level)\n        if (item.methods && item.methods.length > 0) {\n            for (const methodConfig of item.methods) {\n                const methodRegex = this.methodToRegex(methodConfig.method);\n\n                this.rules.push({\n                    componentRegex,\n                    methodRegex,\n                    applyRegex: methodConfig.apply ? this.allowedComponentsToRegex(methodConfig.apply) : undefined,\n                    excludeRegex: methodConfig.exclude ? this.allowedComponentsToRegex(methodConfig.exclude) : undefined,\n                });\n            }\n        }\n    }\n\n\n\n    /**\n     * Convert a constructor to a regex pattern\n     */\n    private constructorToRegex(ctor: A_TYPES__Component_Constructor): RegExp {\n        return new RegExp(`^${this.escapeRegex(ctor.name)}$`);\n    }\n\n    /**\n     * Convert a method name or regex to a regex pattern\n     */\n    private methodToRegex(method: string | RegExp): RegExp {\n        if (method instanceof RegExp) {\n            return method;\n        }\n        return new RegExp(`^${this.escapeRegex(method as string)}$`);\n    }\n\n    /**\n     * Convert allowed components array or regex to a single regex\n     */\n    private allowedComponentsToRegex(components: A_UTILS_TYPES__Manifest_AllowedComponents[] | RegExp): RegExp {\n        if (components instanceof RegExp) {\n            return components;\n        }\n\n        const patterns = components.map(ctor => this.escapeRegex(ctor.name));\n        return new RegExp(`^(${patterns.join('|')})$`);\n    }\n\n    /**\n     * Escape special regex characters in a string\n     */\n    private escapeRegex(str: string): string {\n        return str.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n    }\n\n    protected configItemToRegexp(item: A_TYPES__Component_Constructor): RegExp {\n        return this.constructorToRegex(item);\n    }\n\n\n    protected ID(component: A_TYPES__Component_Constructor, method: string) {\n        return `${component.name}.${method}`;\n    }\n\n    /**\n     * Check if a component and method combination is allowed for a target\n     */\n    isAllowed<T extends A_Component>(\n        ctor: T | A_TYPES__Component_Constructor<T>,\n        method: string\n    ): A_ManifestChecker {\n        const componentCtor = typeof ctor === 'function' ? ctor : ctor.constructor as A_TYPES__Component_Constructor;\n        return new A_ManifestChecker(this, componentCtor, method);\n    }\n\n    /**\n     * Internal method to check if access is allowed\n     */\n    internal_checkAccess(query: A_UTILS_TYPES__ManifestQuery): boolean {\n        const componentName = query.component.name;\n        const methodName = query.method;\n        const targetName = query.target.name;\n\n        // Find matching rules, sorted by specificity (method-specific rules first)\n        const matchingRules = this.rules\n            .filter(rule =>\n                rule.componentRegex.test(componentName) &&\n                rule.methodRegex.test(methodName)\n            )\n            .sort((a, b) => {\n                // Method-specific rules (not .* pattern) should come before general rules\n                const aIsGeneral = a.methodRegex.source === '.*';\n                const bIsGeneral = b.methodRegex.source === '.*';\n\n                if (aIsGeneral && !bIsGeneral) return 1;  // b comes first\n                if (!aIsGeneral && bIsGeneral) return -1; // a comes first\n                return 0; // same priority\n            });\n\n        // If no rules match, allow by default\n        if (matchingRules.length === 0) {\n            return true;\n        }\n\n        // Process rules in order of specificity (most specific first)\n        for (const rule of matchingRules) {\n            // If this rule has an exclusion that matches, deny access\n            if (rule.excludeRegex && rule.excludeRegex.test(targetName)) {\n                return false;\n            }\n\n            // If this rule has an apply list, check if target is in it\n            if (rule.applyRegex) {\n                return rule.applyRegex.test(targetName);\n            }\n        }\n\n        // If we have rules but no specific apply/exclude, allow by default\n        return true;\n    }\n\n    isExcluded<T extends A_Component>(\n        ctor: T | A_TYPES__Component_Constructor<T>,\n        method: string\n    ): A_ManifestChecker {\n        const componentCtor = typeof ctor === 'function' ? ctor : ctor.constructor as A_TYPES__Component_Constructor;\n        return new A_ManifestChecker(this, componentCtor, method, true);\n    }\n}\n"]}