@venizia/ignis 0.1.1-9 → 0.2.0-0

package/dist/helpers/inversion/registry.d.ts

@@ -1,449 +0,0 @@
-import type { AnyType, TClass } from '@venizia/ignis-helpers';
-import { MetadataRegistry as _MetadataRegistry } from '@venizia/ignis-inversion';
-import type { IModelRegistryEntry, IRepositoryBinding } from './common/types';
-declare const BaseRegistry: {
-    new (...args: any[]): {
-        addRpc<Target extends object = object>(opts: {
-            target: Target;
-            methodName: string | symbol;
-            configs: import("./common/types").IRpcMetadata;
-        }): void;
-        getRpcs<Target extends object = object>(opts: {
-            target: Target;
-        }): Map<string | symbol, import("./common/types").IRpcMetadata> | undefined;
-        getRpc<Target extends object = object>(opts: {
-            target: Target;
-            methodName: string | symbol;
-        }): import("./common/types").IRpcMetadata | undefined;
-        hasRpcs<Target extends object = object>(opts: {
-            target: Target;
-        }): boolean;
-        define: <Target extends object = object, Value = any>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-            value: Value;
-        }) => void;
-        get: <Target extends object = object, Value = any>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-        }) => Value | undefined;
-        has: <Target extends object = object>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-        }) => boolean;
-        delete: <Target extends object = object>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-        }) => boolean;
-        getKeys: <Target extends object = object>(opts: {
-            target: Target;
-        }) => import("@venizia/ignis-inversion").TBindingKey[];
-        getMethodNames: <T = any>(opts: {
-            target: import("@venizia/ignis-inversion").TClass<T>;
-        }) => string[];
-        clearMetadata: <T extends object = object>(opts: {
-            target: T;
-        }) => void;
-        setPropertyMetadata: <T extends object = object>(opts: {
-            target: T;
-            propertyName: string | symbol;
-            metadata: import("@venizia/ignis-inversion").IPropertyMetadata;
-        }) => void;
-        getPropertiesMetadata: <T extends object = object>(opts: {
-            target: T;
-        }) => Map<string | symbol, import("@venizia/ignis-inversion").IPropertyMetadata> | undefined;
-        getPropertyMetadata: <T extends object = object>(opts: {
-            target: T;
-            propertyName: string | symbol;
-        }) => import("@venizia/ignis-inversion").IPropertyMetadata | undefined;
-        setInjectMetadata: <T extends object = object>(opts: {
-            target: T;
-            index: number;
-            metadata: import("@venizia/ignis-inversion").IInjectMetadata;
-        }) => void;
-        getInjectMetadata: <T extends object = object>(opts: {
-            target: T;
-        }) => import("@venizia/ignis-inversion").IInjectMetadata[] | undefined;
-        scope: string;
-        identifier: string;
-    };
-} & {
-    new (...args: any[]): {
-        getRoutes<Target extends object = object>(opts: {
-            target: Target;
-        }): Map<string | symbol, import("../..").IAuthRouteConfig> | undefined;
-        getRoute<Target extends object = object>(opts: {
-            target: Target;
-            methodName: string | symbol;
-        }): import("../..").IAuthRouteConfig | undefined;
-        hasRoutes<Target extends object = object>(opts: {
-            target: Target;
-        }): boolean;
-        addRoute<Target extends object = object>(opts: {
-            target: Target;
-            methodName: string | symbol;
-            configs: import("../..").IAuthRouteConfig;
-        }): void;
-        define: <Target extends object = object, Value = any>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-            value: Value;
-        }) => void;
-        get: <Target extends object = object, Value = any>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-        }) => Value | undefined;
-        has: <Target extends object = object>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-        }) => boolean;
-        delete: <Target extends object = object>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-        }) => boolean;
-        getKeys: <Target extends object = object>(opts: {
-            target: Target;
-        }) => import("@venizia/ignis-inversion").TBindingKey[];
-        getMethodNames: <T = any>(opts: {
-            target: import("@venizia/ignis-inversion").TClass<T>;
-        }) => string[];
-        clearMetadata: <T extends object = object>(opts: {
-            target: T;
-        }) => void;
-        setPropertyMetadata: <T extends object = object>(opts: {
-            target: T;
-            propertyName: string | symbol;
-            metadata: import("@venizia/ignis-inversion").IPropertyMetadata;
-        }) => void;
-        getPropertiesMetadata: <T extends object = object>(opts: {
-            target: T;
-        }) => Map<string | symbol, import("@venizia/ignis-inversion").IPropertyMetadata> | undefined;
-        getPropertyMetadata: <T extends object = object>(opts: {
-            target: T;
-            propertyName: string | symbol;
-        }) => import("@venizia/ignis-inversion").IPropertyMetadata | undefined;
-        setInjectMetadata: <T extends object = object>(opts: {
-            target: T;
-            index: number;
-            metadata: import("@venizia/ignis-inversion").IInjectMetadata;
-        }) => void;
-        getInjectMetadata: <T extends object = object>(opts: {
-            target: T;
-        }) => import("@venizia/ignis-inversion").IInjectMetadata[] | undefined;
-        scope: string;
-        identifier: string;
-    };
-} & {
-    new (...args: any[]): {
-        setControllerMetadata<Target extends object = object>(opts: {
-            target: Target;
-            metadata: import("./common/types").TControllerMetadata;
-        }): void;
-        getControllerMetadata<Target extends object = object>(opts: {
-            target: Target;
-        }): import("./common/types").TControllerMetadata | undefined;
-        getRestControllerMetadata<Target extends object = object>(opts: {
-            target: Target;
-        }): import("./common/types").IRestControllerMetadata | undefined;
-        getGrpcControllerMetadata<Target extends object = object>(opts: {
-            target: Target;
-        }): import("./common/types").IGrpcControllerMetadata | undefined;
-        define: <Target extends object = object, Value = any>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-            value: Value;
-        }) => void;
-        get: <Target extends object = object, Value = any>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-        }) => Value | undefined;
-        has: <Target extends object = object>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-        }) => boolean;
-        delete: <Target extends object = object>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-        }) => boolean;
-        getKeys: <Target extends object = object>(opts: {
-            target: Target;
-        }) => import("@venizia/ignis-inversion").TBindingKey[];
-        getMethodNames: <T = any>(opts: {
-            target: import("@venizia/ignis-inversion").TClass<T>;
-        }) => string[];
-        clearMetadata: <T extends object = object>(opts: {
-            target: T;
-        }) => void;
-        setPropertyMetadata: <T extends object = object>(opts: {
-            target: T;
-            propertyName: string | symbol;
-            metadata: import("@venizia/ignis-inversion").IPropertyMetadata;
-        }) => void;
-        getPropertiesMetadata: <T extends object = object>(opts: {
-            target: T;
-        }) => Map<string | symbol, import("@venizia/ignis-inversion").IPropertyMetadata> | undefined;
-        getPropertyMetadata: <T extends object = object>(opts: {
-            target: T;
-            propertyName: string | symbol;
-        }) => import("@venizia/ignis-inversion").IPropertyMetadata | undefined;
-        setInjectMetadata: <T extends object = object>(opts: {
-            target: T;
-            index: number;
-            metadata: import("@venizia/ignis-inversion").IInjectMetadata;
-        }) => void;
-        getInjectMetadata: <T extends object = object>(opts: {
-            target: T;
-        }) => import("@venizia/ignis-inversion").IInjectMetadata[] | undefined;
-        scope: string;
-        identifier: string;
-    };
-} & {
-    new (...args: any[]): {
-        repositoryBindings: Map<string, IRepositoryBinding<import("../..").AbstractEntity>>;
-        datasourceModels: Map<string, Set<TClass<AnyType>>>;
-        setRepositoryMetadata<Target extends object = object, Model extends import("../..").AbstractEntity = import("../..").AbstractEntity<unknown>, DataSource extends import("../..").IDataSource = import("../..").IDataSource<{}, import("../..").TAnyDataSourceSchema, {}>>(opts: {
-            target: Target;
-            metadata: import("./common/types").IRepositoryMetadata<Model, DataSource>;
-        }): void;
-        getRepositoryMetadata<Target extends object = object>(opts: {
-            target: Target;
-        }): (import("./common/types").IRepositoryMetadata<import("../..").AbstractEntity<unknown>, import("../..").IDataSource<{}, import("../..").TAnyDataSourceSchema, {}>> & {
-            _resolved?: import("./common/types").IResolvedRepositoryMetadata;
-        }) | undefined;
-        registerRepositoryBinding<Model extends import("../..").AbstractEntity = import("../..").AbstractEntity<unknown>, DataSource extends import("../..").IDataSource = import("../..").IDataSource<{}, import("../..").TAnyDataSourceSchema, {}>>(opts: IRepositoryBinding<Model, DataSource>): void;
-        getRepositoryBinding(opts: {
-            name: string;
-        }): IRepositoryBinding<import("../..").AbstractEntity> | undefined;
-        resolveModelRelations(modelMeta: IModelRegistryEntry): unknown;
-        getModels(opts: {
-            dataSource: string | TClass<import("../..").IDataSource>;
-        }): {
-            tableName: string;
-            schema: unknown;
-            relations?: unknown;
-        }[];
-        getModelClasses(opts: {
-            dataSource: string | TClass<import("../..").IDataSource>;
-        }): Array<TClass<unknown>>;
-        resolveModelKey(opts: {
-            modelClass: TClass<AnyType>;
-        }): string;
-        buildSchema(opts: {
-            dataSource: string | TClass<import("../..").IDataSource>;
-        }): {
-            schema: Record<string, unknown>;
-            relations: Record<string, unknown>;
-        };
-        hasModels(opts: {
-            dataSource: string | TClass<import("../..").IDataSource>;
-        }): boolean;
-        define: <Target extends object = object, Value = any>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-            value: Value;
-        }) => void;
-        get: <Target extends object = object, Value = any>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-        }) => Value | undefined;
-        has: <Target extends object = object>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-        }) => boolean;
-        delete: <Target extends object = object>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-        }) => boolean;
-        getKeys: <Target extends object = object>(opts: {
-            target: Target;
-        }) => import("@venizia/ignis-inversion").TBindingKey[];
-        getMethodNames: <T = any>(opts: {
-            target: import("@venizia/ignis-inversion").TClass<T>;
-        }) => string[];
-        clearMetadata: <T extends object = object>(opts: {
-            target: T;
-        }) => void;
-        setPropertyMetadata: <T extends object = object>(opts: {
-            target: T;
-            propertyName: string | symbol;
-            metadata: import("@venizia/ignis-inversion").IPropertyMetadata;
-        }) => void;
-        getPropertiesMetadata: <T extends object = object>(opts: {
-            target: T;
-        }) => Map<string | symbol, import("@venizia/ignis-inversion").IPropertyMetadata> | undefined;
-        getPropertyMetadata: <T extends object = object>(opts: {
-            target: T;
-            propertyName: string | symbol;
-        }) => import("@venizia/ignis-inversion").IPropertyMetadata | undefined;
-        setInjectMetadata: <T extends object = object>(opts: {
-            target: T;
-            index: number;
-            metadata: import("@venizia/ignis-inversion").IInjectMetadata;
-        }) => void;
-        getInjectMetadata: <T extends object = object>(opts: {
-            target: T;
-        }) => import("@venizia/ignis-inversion").IInjectMetadata[] | undefined;
-        scope: string;
-        identifier: string;
-        modelRegistry: Map<string, IModelRegistryEntry>;
-        getModelMetadata: (opts: {
-            target: object;
-        }) => import("./common/types").IModelMetadata | undefined;
-    };
-} & {
-    new (...args: any[]): {
-        modelRegistry: Map<string, IModelRegistryEntry>;
-        setModelMetadata<Target extends object = object>(opts: {
-            target: Target;
-            metadata: import("./common/types").IModelMetadata;
-        }): void;
-        getModelMetadata<Target extends object = object>(opts: {
-            target: Target;
-        }): import("./common/types").IModelMetadata | undefined;
-        registerModel<Model extends import("../..").AbstractEntity = import("../..").AbstractEntity<unknown>>(opts: {
-            target: import("./common/types").TDecoratorModelTarget<Model>;
-            metadata: import("./common/types").IModelMetadata;
-        }): void;
-        getModelEntry(opts: {
-            name: string;
-        }): IModelRegistryEntry | undefined;
-        getAllModels(): Map<string, IModelRegistryEntry>;
-        getModelAuthorizeSettings(opts: {
-            name: string;
-        }): import("./common/types").IModelAuthorizeSettings | undefined;
-        getAuthorizeModelPrincipals(opts: {
-            format: "array";
-        }): string[];
-        getAuthorizeModelPrincipals(opts: {
-            format: "record";
-        }): Record<string, string>;
-        getAuthorizeModelSettings(opts: {
-            format: "array";
-        }): {
-            name: string;
-            authorize: import("./common/types").IModelAuthorizeSettings;
-            entry: IModelRegistryEntry;
-        }[];
-        getAuthorizeModelSettings(opts: {
-            format: "record";
-        }): Record<string, {
-            authorize: import("./common/types").IModelAuthorizeSettings;
-            entry: IModelRegistryEntry;
-        }>;
-        define: <Target extends object = object, Value = any>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-            value: Value;
-        }) => void;
-        get: <Target extends object = object, Value = any>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-        }) => Value | undefined;
-        has: <Target extends object = object>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-        }) => boolean;
-        delete: <Target extends object = object>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-        }) => boolean;
-        getKeys: <Target extends object = object>(opts: {
-            target: Target;
-        }) => import("@venizia/ignis-inversion").TBindingKey[];
-        getMethodNames: <T = any>(opts: {
-            target: import("@venizia/ignis-inversion").TClass<T>;
-        }) => string[];
-        clearMetadata: <T extends object = object>(opts: {
-            target: T;
-        }) => void;
-        setPropertyMetadata: <T extends object = object>(opts: {
-            target: T;
-            propertyName: string | symbol;
-            metadata: import("@venizia/ignis-inversion").IPropertyMetadata;
-        }) => void;
-        getPropertiesMetadata: <T extends object = object>(opts: {
-            target: T;
-        }) => Map<string | symbol, import("@venizia/ignis-inversion").IPropertyMetadata> | undefined;
-        getPropertyMetadata: <T extends object = object>(opts: {
-            target: T;
-            propertyName: string | symbol;
-        }) => import("@venizia/ignis-inversion").IPropertyMetadata | undefined;
-        setInjectMetadata: <T extends object = object>(opts: {
-            target: T;
-            index: number;
-            metadata: import("@venizia/ignis-inversion").IInjectMetadata;
-        }) => void;
-        getInjectMetadata: <T extends object = object>(opts: {
-            target: T;
-        }) => import("@venizia/ignis-inversion").IInjectMetadata[] | undefined;
-        scope: string;
-        identifier: string;
-    };
-} & {
-    new (...args: any[]): {
-        setDataSourceMetadata<Target extends object = object>(opts: {
-            target: Target;
-            metadata?: import("./common/types").IDataSourceMetadata;
-        }): void;
-        getDataSourceMetadata<Target extends object = object>(opts: {
-            target: Target;
-        }): import("./common/types").IDataSourceMetadata | undefined;
-        define: <Target extends object = object, Value = any>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-            value: Value;
-        }) => void;
-        get: <Target extends object = object, Value = any>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-        }) => Value | undefined;
-        has: <Target extends object = object>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-        }) => boolean;
-        delete: <Target extends object = object>(opts: {
-            target: Target;
-            key: import("@venizia/ignis-inversion").TBindingKey;
-        }) => boolean;
-        getKeys: <Target extends object = object>(opts: {
-            target: Target;
-        }) => import("@venizia/ignis-inversion").TBindingKey[];
-        getMethodNames: <T = any>(opts: {
-            target: import("@venizia/ignis-inversion").TClass<T>;
-        }) => string[];
-        clearMetadata: <T extends object = object>(opts: {
-            target: T;
-        }) => void;
-        setPropertyMetadata: <T extends object = object>(opts: {
-            target: T;
-            propertyName: string | symbol;
-            metadata: import("@venizia/ignis-inversion").IPropertyMetadata;
-        }) => void;
-        getPropertiesMetadata: <T extends object = object>(opts: {
-            target: T;
-        }) => Map<string | symbol, import("@venizia/ignis-inversion").IPropertyMetadata> | undefined;
-        getPropertyMetadata: <T extends object = object>(opts: {
-            target: T;
-            propertyName: string | symbol;
-        }) => import("@venizia/ignis-inversion").IPropertyMetadata | undefined;
-        setInjectMetadata: <T extends object = object>(opts: {
-            target: T;
-            index: number;
-            metadata: import("@venizia/ignis-inversion").IInjectMetadata;
-        }) => void;
-        getInjectMetadata: <T extends object = object>(opts: {
-            target: T;
-        }) => import("@venizia/ignis-inversion").IInjectMetadata[] | undefined;
-        scope: string;
-        identifier: string;
-    };
-} & typeof _MetadataRegistry;
-/** Central metadata registry: decorator metadata, the model registry, repository bindings and auto-discovery. */
-export declare class MetadataRegistry extends BaseRegistry {
-    private static instance;
-    private constructor();
-    static getInstance(): MetadataRegistry;
-    clearAll(): void;
-}
-export {};
-//# sourceMappingURL=registry.d.ts.map

package/dist/helpers/inversion/registry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/helpers/inversion/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,gBAAgB,IAAI,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AACjF,OAAO,KAAK,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAU9E,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAMjB,CAAC;AAEF,iHAAiH;AACjH,qBAAa,gBAAiB,SAAQ,YAAY;IAChD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAmB;IAE1C,OAAO;IAOP,MAAM,CAAC,WAAW,IAAI,gBAAgB;IAOtC,QAAQ,IAAI,IAAI;CAKjB"}

package/dist/helpers/inversion/registry.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MetadataRegistry = void 0;
-const ignis_inversion_1 = require("@venizia/ignis-inversion");
-const mixins_1 = require("./mixins");
-const BaseRegistry = (0, mixins_1.GrpcControllerMetadataMixin)((0, mixins_1.RestControllerMetadataMixin)((0, mixins_1.ControllerMetadataMixin)((0, mixins_1.RepositoryMetadataMixin)((0, mixins_1.ModelMetadataMixin)((0, mixins_1.DatasourceMetadataMixin)(ignis_inversion_1.MetadataRegistry))))));
-/** Central metadata registry: decorator metadata, the model registry, repository bindings and auto-discovery. */
-class MetadataRegistry extends BaseRegistry {
-    constructor() {
-        super();
-        this.modelRegistry = new Map();
-        this.repositoryBindings = new Map();
-        this.datasourceModels = new Map();
-    }
-    static getInstance() {
-        if (!MetadataRegistry.instance) {
-            MetadataRegistry.instance = new MetadataRegistry();
-        }
-        return MetadataRegistry.instance;
-    }
-    clearAll() {
-        this.modelRegistry.clear();
-        this.repositoryBindings.clear();
-        this.datasourceModels.clear();
-    }
-}
-exports.MetadataRegistry = MetadataRegistry;
-//# sourceMappingURL=registry.js.map

package/dist/helpers/inversion/registry.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../../src/helpers/inversion/registry.ts"],"names":[],"mappings":";;;AACA,8DAAiF;AAEjF,qCAOkB;AAElB,MAAM,YAAY,GAAG,IAAA,oCAA2B,EAC9C,IAAA,oCAA2B,EACzB,IAAA,gCAAuB,EACrB,IAAA,gCAAuB,EAAC,IAAA,2BAAkB,EAAC,IAAA,gCAAuB,EAAC,kCAAiB,CAAC,CAAC,CAAC,CACxF,CACF,CACF,CAAC;AAEF,iHAAiH;AACjH,MAAa,gBAAiB,SAAQ,YAAY;IAGhD;QACE,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,aAAa,GAAG,IAAI,GAAG,EAA+B,CAAC;QAC5D,IAAI,CAAC,kBAAkB,GAAG,IAAI,GAAG,EAA8B,CAAC;QAChE,IAAI,CAAC,gBAAgB,GAAG,IAAI,GAAG,EAAgC,CAAC;IAClE,CAAC;IAED,MAAM,CAAC,WAAW;QAChB,IAAI,CAAC,gBAAgB,CAAC,QAAQ,EAAE,CAAC;YAC/B,gBAAgB,CAAC,QAAQ,GAAG,IAAI,gBAAgB,EAAE,CAAC;QACrD,CAAC;QACD,OAAO,gBAAgB,CAAC,QAAQ,CAAC;IACnC,CAAC;IAED,QAAQ;QACN,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;QAC3B,IAAI,CAAC,kBAAkB,CAAC,KAAK,EAAE,CAAC;QAChC,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,CAAC;IAChC,CAAC;CACF;AAtBD,4CAsBC"}

package/dist/utilities/error.utility.d.ts

@@ -1,8 +0,0 @@
-import type { ILogger } from '@venizia/ignis-helpers';
-/** Standardized NotSupported error (HTTP 501) for a capability an implementation deliberately does not provide - logs a warning before throwing so the gap shows in operational logs, not just to the caller. */
-export declare const throwNotSupported: (opts: {
-    scope: string;
-    feature: string;
-    logger: ILogger;
-}) => never;
-//# sourceMappingURL=error.utility.d.ts.map

package/dist/utilities/error.utility.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"error.utility.d.ts","sourceRoot":"","sources":["../../src/utilities/error.utility.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAGtD,iNAAiN;AACjN,eAAO,MAAM,iBAAiB,GAAI,MAAM;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;CACjB,KAAG,KAUH,CAAC"}

package/dist/utilities/error.utility.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.throwNotSupported = void 0;
-const common_1 = require("../common");
-const ignis_helpers_1 = require("@venizia/ignis-helpers");
-/** Standardized NotSupported error (HTTP 501) for a capability an implementation deliberately does not provide - logs a warning before throwing so the gap shows in operational logs, not just to the caller. */
-const throwNotSupported = (opts) => {
-    const { scope, feature, logger } = opts;
-    logger.for(exports.throwNotSupported.name).warn('%s is not supported | Scope: %s', feature, scope);
-    throw (0, ignis_helpers_1.getError)({
-        statusCode: ignis_helpers_1.HTTP.ResultCodes.RS_5.NotImplemented,
-        messageCode: common_1.CoreErrorCodes.NOT_SUPPORTED,
-        message: `[${scope}] ${feature} is not supported.`,
-    });
-};
-exports.throwNotSupported = throwNotSupported;
-//# sourceMappingURL=error.utility.js.map

package/dist/utilities/error.utility.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"error.utility.js","sourceRoot":"","sources":["../../src/utilities/error.utility.ts"],"names":[],"mappings":";;;AAAA,qCAA0C;AAE1C,0DAAwD;AAExD,iNAAiN;AAC1M,MAAM,iBAAiB,GAAG,CAAC,IAIjC,EAAS,EAAE;IACV,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IAExC,MAAM,CAAC,GAAG,CAAC,yBAAiB,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,iCAAiC,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;IAE3F,MAAM,IAAA,wBAAQ,EAAC;QACb,UAAU,EAAE,oBAAI,CAAC,WAAW,CAAC,IAAI,CAAC,cAAc;QAChD,WAAW,EAAE,uBAAc,CAAC,aAAa;QACzC,OAAO,EAAE,IAAI,KAAK,KAAK,OAAO,oBAAoB;KACnD,CAAC,CAAC;AACL,CAAC,CAAC;AAdW,QAAA,iBAAiB,qBAc5B"}

package/dist/utilities/jsx.utility.d.ts

@@ -1,49 +0,0 @@
-import { z } from '@hono/zod-openapi';
-/** Creates HTML content configuration for OpenAPI documentation. */
-export declare const htmlContent: (opts: {
-    description: string;
-    required?: boolean;
-}) => {
-    description: string;
-    content: {
-        'text/html': {
-            schema: z.ZodString;
-        };
-    };
-    required: boolean;
-};
-/** Creates HTML response configuration for OpenAPI documentation. */
-export declare const htmlResponse: (opts: {
-    description: string;
-    required?: boolean;
-}) => {
-    200: {
-        description: string;
-        content: {
-            'text/html': {
-                schema: z.ZodString;
-            };
-        };
-        required: boolean;
-    };
-    "4xx | 5xx": {
-        description: string;
-        content: {
-            'application/json': {
-                schema: z.ZodObject<{
-                    statusCode: z.ZodOptional<z.ZodNumber>;
-                    message: z.ZodString;
-                    normalized: z.ZodOptional<z.ZodObject<{
-                        text: z.ZodString;
-                        code: z.ZodString;
-                        args: z.ZodRecord<z.ZodString, z.ZodAny>;
-                    }, z.core.$strip>>;
-                    extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-                    requestId: z.ZodOptional<z.ZodString>;
-                    details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-                }, z.core.$strip>;
-            };
-        };
-    };
-};
-//# sourceMappingURL=jsx.utility.d.ts.map

package/dist/utilities/jsx.utility.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"jsx.utility.d.ts","sourceRoot":"","sources":["../../src/utilities/jsx.utility.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAGtC,oEAAoE;AACpE,eAAO,MAAM,WAAW,GAAI,MAAM;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE;;;;;;;;CAe5E,CAAC;AAEF,qEAAqE;AACrE,eAAO,MAAM,YAAY,GAAI,MAAM;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAe7E,CAAC"}

package/dist/utilities/jsx.utility.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.htmlResponse = exports.htmlContent = void 0;
-const zod_openapi_1 = require("@hono/zod-openapi");
-const ignis_helpers_1 = require("@venizia/ignis-helpers");
-/** Creates HTML content configuration for OpenAPI documentation. */
-const htmlContent = (opts) => {
-    const { description } = opts;
-    return {
-        description,
-        content: {
-            'text/html': {
-                schema: zod_openapi_1.z.string().openapi({
-                    description: 'HTML content',
-                    example: '<!DOCTYPE html><html><head><title>Page</title></head><body>...</body></html>',
-                }),
-            },
-        },
-        required: opts?.required ?? false,
-    };
-};
-exports.htmlContent = htmlContent;
-/** Creates HTML response configuration for OpenAPI documentation. */
-const htmlResponse = (opts) => {
-    return {
-        [ignis_helpers_1.HTTP.ResultCodes.RS_2.Ok]: (0, exports.htmlContent)({
-            description: opts.description,
-            required: opts.required,
-        }),
-        ['4xx | 5xx']: {
-            description: 'Error Response',
-            content: {
-                'application/json': {
-                    schema: ignis_helpers_1.ErrorSchema,
-                },
-            },
-        },
-    };
-};
-exports.htmlResponse = htmlResponse;
-//# sourceMappingURL=jsx.utility.js.map

package/dist/utilities/jsx.utility.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"jsx.utility.js","sourceRoot":"","sources":["../../src/utilities/jsx.utility.ts"],"names":[],"mappings":";;;AAAA,mDAAsC;AACtC,0DAA2D;AAE3D,oEAAoE;AAC7D,MAAM,WAAW,GAAG,CAAC,IAAiD,EAAE,EAAE;IAC/E,MAAM,EAAE,WAAW,EAAE,GAAG,IAAI,CAAC;IAE7B,OAAO;QACL,WAAW;QACX,OAAO,EAAE;YACP,WAAW,EAAE;gBACX,MAAM,EAAE,eAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC;oBACzB,WAAW,EAAE,cAAc;oBAC3B,OAAO,EAAE,8EAA8E;iBACxF,CAAC;aACH;SACF;QACD,QAAQ,EAAE,IAAI,EAAE,QAAQ,IAAI,KAAK;KAClC,CAAC;AACJ,CAAC,CAAC;AAfW,QAAA,WAAW,eAetB;AAEF,qEAAqE;AAC9D,MAAM,YAAY,GAAG,CAAC,IAAiD,EAAE,EAAE;IAChF,OAAO;QACL,CAAC,oBAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,IAAA,mBAAW,EAAC;YACtC,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,QAAQ,EAAE,IAAI,CAAC,QAAQ;SACxB,CAAC;QACF,CAAC,WAAW,CAAC,EAAE;YACb,WAAW,EAAE,gBAAgB;YAC7B,OAAO,EAAE;gBACP,kBAAkB,EAAE;oBAClB,MAAM,EAAE,2BAAW;iBACpB;aACF;SACF;KACF,CAAC;AACJ,CAAC,CAAC;AAfW,QAAA,YAAY,gBAevB"}

package/dist/utilities/schema.utility.d.ts

@@ -1,10 +0,0 @@
-import { z } from '@hono/zod-openapi';
-export declare const requiredString: (opts?: {
-    min?: number;
-    max?: number;
-    fixed?: number;
-}) => z.ZodString;
-export declare const AnyObjectSchema: z.ZodObject<{}, z.core.$catchall<z.ZodAny>>;
-export type TAnyObjectSchema = z.ZodObject<z.ZodRawShape>;
-export type TInferSchema<T extends z.ZodTypeAny> = z.infer<T>;
-//# sourceMappingURL=schema.utility.d.ts.map

package/dist/utilities/schema.utility.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema.utility.d.ts","sourceRoot":"","sources":["../../src/utilities/schema.utility.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAEtC,eAAO,MAAM,cAAc,GAAI,OAAO;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,gBAiBnF,CAAC;AAEF,eAAO,MAAM,eAAe,6CAE1B,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC;AAC1D,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC"}

package/dist/utilities/schema.utility.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AnyObjectSchema = exports.requiredString = void 0;
-const zod_openapi_1 = require("@hono/zod-openapi");
-const requiredString = (opts) => {
-    const { min, max, fixed } = opts ?? {};
-    let rs = zod_openapi_1.z.string().nonempty();
-    if (min) {
-        rs = rs.min(min);
-    }
-    if (max) {
-        rs = rs.max(max);
-    }
-    if (fixed) {
-        rs = rs.length(fixed);
-    }
-    return rs;
-};
-exports.requiredString = requiredString;
-exports.AnyObjectSchema = zod_openapi_1.z.object().catchall(zod_openapi_1.z.any()).openapi({
-    description: 'Unknown schema',
-});
-//# sourceMappingURL=schema.utility.js.map