@imbricate/core 2.6.2 → 3.0.1

package/loader/origin-loader.js

@@ -0,0 +1,74 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Loader
+ * @description Origin Loader
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadImbricateOriginsFromPersistance = exports.loadImbricateOriginFromPersistanceOrigin = void 0;
+const persistance_1 = require("./persistance");
+const loadImbricateOriginFromPersistanceOrigin = (origin) => __awaiter(void 0, void 0, void 0, function* () {
+    switch (origin.originLoadType) {
+        case persistance_1.IMBRICATE_ORIGIN_LOAD_TYPE.NPM_PACKAGE: {
+            const originPackage = yield Promise.resolve(`${origin.originLoadValue}`).then(s => __importStar(require(s)));
+            if (typeof originPackage.default === "function") {
+                const initialized = originPackage.default.call(null, origin.originPayloads);
+                return initialized;
+            }
+            break;
+        }
+        case persistance_1.IMBRICATE_ORIGIN_LOAD_TYPE.FILE_SYSTEM: {
+            const originPackage = yield Promise.resolve(`${origin.originLoadValue}`).then(s => __importStar(require(s)));
+            if (typeof originPackage.default === "function") {
+                const initialized = originPackage.default.call(null, origin.originPayloads);
+                return initialized;
+            }
+            break;
+        }
+    }
+    return null;
+});
+exports.loadImbricateOriginFromPersistanceOrigin = loadImbricateOriginFromPersistanceOrigin;
+const loadImbricateOriginsFromPersistance = (persistance) => __awaiter(void 0, void 0, void 0, function* () {
+    const origins = [];
+    for (const origin of persistance.origins) {
+        const originInstance = yield (0, exports.loadImbricateOriginFromPersistanceOrigin)(origin);
+        if (originInstance) {
+            origins.push(originInstance);
+        }
+    }
+    return origins;
+});
+exports.loadImbricateOriginsFromPersistance = loadImbricateOriginsFromPersistance;

package/loader/persistance.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @author WMXPY
+ * @namespace Loader
+ * @description Persistance
+ */
+import { OriginPayload } from "../origin/definition";
+export declare enum IMBRICATE_ORIGIN_LOAD_TYPE {
+    NPM_PACKAGE = "NPM_PACKAGE",
+    FILE_SYSTEM = "FILE_SYSTEM"
+}
+export type ImbricateOriginPersistanceOrigin = {
+    readonly originLoadType: IMBRICATE_ORIGIN_LOAD_TYPE;
+    readonly originLoadValue: string;
+    readonly originName: string;
+    readonly originPayloads: OriginPayload;
+};
+export type ImbricateOriginPersistance = {
+    readonly origins: ImbricateOriginPersistanceOrigin[];
+};

package/loader/persistance.js

@@ -0,0 +1,13 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Loader
+ * @description Persistance
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IMBRICATE_ORIGIN_LOAD_TYPE = void 0;
+var IMBRICATE_ORIGIN_LOAD_TYPE;
+(function (IMBRICATE_ORIGIN_LOAD_TYPE) {
+    IMBRICATE_ORIGIN_LOAD_TYPE["NPM_PACKAGE"] = "NPM_PACKAGE";
+    IMBRICATE_ORIGIN_LOAD_TYPE["FILE_SYSTEM"] = "FILE_SYSTEM";
+})(IMBRICATE_ORIGIN_LOAD_TYPE || (exports.IMBRICATE_ORIGIN_LOAD_TYPE = IMBRICATE_ORIGIN_LOAD_TYPE = {}));

package/origin/definition.d.ts

@@ -3,22 +3,4 @@
  * @namespace Origin
  * @description Definition
  */
-import { ImbricateCapability } from "../capability/definition";
-export declare enum IMBRICATE_DIGEST_ALGORITHM {
-    MD5 = "MD5",
-    SHA1 = "SHA1",
-    SHA256 = "SHA256"
-}
-export type ImbricateOriginMetadata = {
-    readonly digestAlgorithm: IMBRICATE_DIGEST_ALGORITHM;
-};
-export type ImbricateOriginCapability = Record<IMBRICATE_ORIGIN_CAPABILITY_KEY, ImbricateCapability>;
-export declare enum IMBRICATE_ORIGIN_CAPABILITY_KEY {
-    ORIGIN_FUNCTION = "imbricate.origin.function",
-    ORIGIN_BINARY_STORAGE = "imbricate.origin.binary-storage",
-    ORIGIN_TRASH_STASH = "imbricate.origin.trash-stash",
-    ORIGIN_SCRIPT_MANAGER = "imbricate.origin.script-manager",
-    ORIGIN_COLLECTION_MANAGER = "imbricate.origin.collection-manager",
-    ORIGIN_OPERATION_MANAGER = "imbricate.origin.operation-manager"
-}
-export declare const ImbricateOriginCapabilityList: IMBRICATE_ORIGIN_CAPABILITY_KEY[];
+export type OriginPayload = Record<string, any>;

package/origin/definition.js

@@ -5,27 +5,3 @@
  * @description Definition
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImbricateOriginCapabilityList = exports.IMBRICATE_ORIGIN_CAPABILITY_KEY = exports.IMBRICATE_DIGEST_ALGORITHM = void 0;
-var IMBRICATE_DIGEST_ALGORITHM;
-(function (IMBRICATE_DIGEST_ALGORITHM) {
-    IMBRICATE_DIGEST_ALGORITHM["MD5"] = "MD5";
-    IMBRICATE_DIGEST_ALGORITHM["SHA1"] = "SHA1";
-    IMBRICATE_DIGEST_ALGORITHM["SHA256"] = "SHA256";
-})(IMBRICATE_DIGEST_ALGORITHM || (exports.IMBRICATE_DIGEST_ALGORITHM = IMBRICATE_DIGEST_ALGORITHM = {}));
-var IMBRICATE_ORIGIN_CAPABILITY_KEY;
-(function (IMBRICATE_ORIGIN_CAPABILITY_KEY) {
-    IMBRICATE_ORIGIN_CAPABILITY_KEY["ORIGIN_FUNCTION"] = "imbricate.origin.function";
-    IMBRICATE_ORIGIN_CAPABILITY_KEY["ORIGIN_BINARY_STORAGE"] = "imbricate.origin.binary-storage";
-    IMBRICATE_ORIGIN_CAPABILITY_KEY["ORIGIN_TRASH_STASH"] = "imbricate.origin.trash-stash";
-    IMBRICATE_ORIGIN_CAPABILITY_KEY["ORIGIN_SCRIPT_MANAGER"] = "imbricate.origin.script-manager";
-    IMBRICATE_ORIGIN_CAPABILITY_KEY["ORIGIN_COLLECTION_MANAGER"] = "imbricate.origin.collection-manager";
-    IMBRICATE_ORIGIN_CAPABILITY_KEY["ORIGIN_OPERATION_MANAGER"] = "imbricate.origin.operation-manager";
-})(IMBRICATE_ORIGIN_CAPABILITY_KEY || (exports.IMBRICATE_ORIGIN_CAPABILITY_KEY = IMBRICATE_ORIGIN_CAPABILITY_KEY = {}));
-exports.ImbricateOriginCapabilityList = [
-    IMBRICATE_ORIGIN_CAPABILITY_KEY.ORIGIN_FUNCTION,
-    IMBRICATE_ORIGIN_CAPABILITY_KEY.ORIGIN_BINARY_STORAGE,
-    IMBRICATE_ORIGIN_CAPABILITY_KEY.ORIGIN_TRASH_STASH,
-    IMBRICATE_ORIGIN_CAPABILITY_KEY.ORIGIN_SCRIPT_MANAGER,
-    IMBRICATE_ORIGIN_CAPABILITY_KEY.ORIGIN_COLLECTION_MANAGER,
-    IMBRICATE_ORIGIN_CAPABILITY_KEY.ORIGIN_OPERATION_MANAGER,
-];

package/origin/interface.d.ts

@@ -3,67 +3,42 @@
  * @namespace Origin
  * @description Interface
  */
-import { IImbricateBinaryStorage } from "../binary-storage/interface";
-import { IImbricateCollectionManager } from "../collection-manager/interface";
-import { PromiseOr } from "../definition/promise";
-import { IImbricateFunctionManager } from "../function/interface";
-import { IImbricateOriginOperationManager } from "../origin-operation-manager/interface";
-import { IImbricateScriptManager } from "../script-manager/interface";
-import { ImbricateOriginCapability, ImbricateOriginMetadata } from "./definition";
+import { IImbricateDatabaseManager } from "../database/manager";
+import { IImbricateStaticManager } from "../static/manager";
+import { IImbricateTextManager } from "../text/manager";
+import { OriginPayload } from "./definition";
 export interface IImbricateOrigin {
-    /**
-     * Origin type
-     */
-    readonly originType: string;
     /**
      * Unique identifier of the origin
      */
     readonly uniqueIdentifier: string;
     /**
-     * Metadata of the origin
-     */
-    readonly metadata: ImbricateOriginMetadata;
-    /**
-     * Payloads of the origin
-     */
-    readonly payloads: Record<string, any>;
-    /**
-     * Capabilities of the origin
-     */
-    readonly capabilities: ImbricateOriginCapability;
-    /**
-     * Get function manager
-     *
-     * @returns Function manager
-     */
-    getFunctionManager(): IImbricateFunctionManager;
-    /**
-     * Get binary storage
-     *
-     * @returns Binary storage
+     * Payloads to initialize the origin
      */
-    getBinaryStorage(): IImbricateBinaryStorage;
+    readonly payloads: OriginPayload;
     /**
-     * Get Script manager
+     * Get the database manager of the origin
      *
-     * @returns Script manager
+     * @returns the database manager
      */
-    getScriptManager(): IImbricateScriptManager;
+    getDatabaseManager(): IImbricateDatabaseManager;
     /**
-     * Get collection manager
+     * Get the text manager of the origin
+     *  The text manager is used to manage text objects
      *
-     * @returns Collection manager
+     * @returns the text manager
      */
-    getCollectionManager(): IImbricateCollectionManager;
+    getTextManager(): IImbricateTextManager;
     /**
-     * Get operation manager
+     * Get the static manager of the origin
+     *  The static manager is used to manage static objects
      *
-     * @returns Operation manager
+     * @returns the static manager
      */
-    getOperationManager(): IImbricateOriginOperationManager;
+    getStaticManager(): IImbricateStaticManager;
     /**
      * Dispose the origin, optional
      * This method will be called when the origin is no longer needed
      */
-    dispose?(): PromiseOr<void>;
+    dispose?(): PromiseLike<void>;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@imbricate/core",
   "main": "index.js",
-  "version": "2.6.2",
+  "version": "3.0.1",
   "description": "Imbricate Core, Notebook for Engineers",
   "repository": {
     "type": "git",

package/static/interface.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @author WMXPY
+ * @namespace Static
+ * @description Interface
+ */
+export interface IImbricateStatic {
+    /**
+     * Unique identifier of the static object
+     */
+    readonly uniqueIdentifier: string;
+    /**
+     * Get the content of the static object
+     *
+     * @returns a promise of the content of the text, encoded in base64
+     */
+    getContentInBase64(): PromiseLike<string>;
+}

package/{script → static}/interface.js

@@ -1,7 +1,7 @@
 "use strict";
 /**
  * @author WMXPY
- * @namespace Script
+ * @namespace Static
  * @description Interface
  */
 Object.defineProperty(exports, "__esModule", { value: true });

package/static/manager.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @author WMXPY
+ * @namespace Static
+ * @description Manager
+ */
+import { IImbricateStatic } from "./interface";
+export interface IImbricateStaticManager {
+    /**
+     * Get the static object from the origin
+     *
+     * @returns a promise of the static object, null if not found
+     */
+    getStatic(uniqueIdentifier: string): PromiseLike<IImbricateStatic | null>;
+    /**
+     * Create a new static object in the origin, encoded in base64
+     *  Static object is immutable, once created, it cannot be changed
+     *  Patch a new static object if you want to change the content
+     *
+     * @param content content of the static object, encoded in base64
+     * @param uniqueIdentifier unique identifier of the static object, optional
+     *  if not provided, a unique identifier will be generated
+     *
+     * @returns a promise of the created static object
+     */
+    createInBase64(content: string, uniqueIdentifier?: string): PromiseLike<IImbricateStatic>;
+}

package/{query/script.js → static/manager.js}

@@ -1,7 +1,7 @@
 "use strict";
 /**
  * @author WMXPY
- * @namespace Query
- * @description Script
+ * @namespace Static
+ * @description Manager
  */
 Object.defineProperty(exports, "__esModule", { value: true });

package/text/interface.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @author WMXPY
+ * @namespace Text
+ * @description Interface
+ */
+export interface IImbricateText {
+    /**
+     * Unique identifier of the text object
+     */
+    readonly uniqueIdentifier: string;
+    /**
+     * Get the content of the text object
+     *
+     * @returns a promise of the content of the text object
+     */
+    getContent(): PromiseLike<string>;
+}

package/{page → text}/interface.js

@@ -1,7 +1,7 @@
 "use strict";
 /**
  * @author WMXPY
- * @namespace Page
+ * @namespace Text
  * @description Interface
  */
 Object.defineProperty(exports, "__esModule", { value: true });

package/text/manager.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @author WMXPY
+ * @namespace Text
+ * @description Manager
+ */
+import { IImbricateText } from "./interface";
+export interface IImbricateTextManager {
+    /**
+     * Get the text object from the origin
+     *
+     * @returns a promise of the text object, null if not found
+     */
+    getText(uniqueIdentifier: string): PromiseLike<IImbricateText | null>;
+    /**
+     * Create a new text object in the origin
+     *  Text object is immutable, once created, it cannot be changed
+     *  Patch a new text object if you want to change the content
+     *
+     * @param content content of the text
+     * @param uniqueIdentifier unique identifier of the text object, optional
+     *  if not provided, a unique identifier will be generated
+     *
+     * @returns a promise of the text object
+     */
+    createText(content: string, uniqueIdentifier?: string): PromiseLike<IImbricateText>;
+}

package/{query/page.js → text/manager.js}

@@ -1,7 +1,7 @@
 "use strict";
 /**
  * @author WMXPY
- * @namespace Query
- * @description Page
+ * @namespace Text
+ * @description Manager
  */
 Object.defineProperty(exports, "__esModule", { value: true });

package/binary-storage/base.d.ts

@@ -1,18 +0,0 @@
-/**
- * @author WMXPY
- * @namespace BinaryStorage
- * @description Base
- */
-import { ImbricateCapabilityBuilder } from "../capability/builder";
-import { ImbricateCapability } from "../capability/definition";
-import type { PromiseOr } from "../definition/promise";
-import { IMBRICATE_BINARY_STORAGE_CAPABILITY_KEY, ImbricateBinaryStorageCapability } from "./definition";
-import type { IImbricateBinaryStorage } from "./interface";
-export declare abstract class ImbricateBinaryStorageBase implements IImbricateBinaryStorage {
-    static buildCapability(initial?: ImbricateCapability): ImbricateCapabilityBuilder<IMBRICATE_BINARY_STORAGE_CAPABILITY_KEY>;
-    static allAllowCapability(): ImbricateBinaryStorageCapability;
-    static allDenyCapability(): ImbricateBinaryStorageCapability;
-    abstract readonly capabilities: ImbricateBinaryStorageCapability;
-    putBinaryBase64(_binary: string, _fileName: string): PromiseOr<string>;
-    validateBinaryBase64(_binary: string): PromiseOr<boolean>;
-}

package/binary-storage/base.js

@@ -1,30 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace BinaryStorage
- * @description Base
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImbricateBinaryStorageBase = void 0;
-const builder_1 = require("../capability/builder");
-const definition_1 = require("../capability/definition");
-const not_implemented_1 = require("../error/not-implemented");
-const definition_2 = require("./definition");
-class ImbricateBinaryStorageBase {
-    static buildCapability(initial = (0, definition_1.createDenyImbricateCapability)()) {
-        return builder_1.ImbricateCapabilityBuilder.create(definition_2.ImbricateBinaryStorageCapabilityList, initial);
-    }
-    static allAllowCapability() {
-        return this.buildCapability((0, definition_1.createAllowImbricateCapability)()).build();
-    }
-    static allDenyCapability() {
-        return this.buildCapability((0, definition_1.createDenyImbricateCapability)()).build();
-    }
-    putBinaryBase64(_binary, _fileName) {
-        throw not_implemented_1.ImbricateNotImplemented.create("PutBinaryBase64", definition_2.IMBRICATE_BINARY_STORAGE_CAPABILITY_KEY.UPLOAD_FILE);
-    }
-    validateBinaryBase64(_binary) {
-        throw not_implemented_1.ImbricateNotImplemented.create("ValidateBinaryBase64", definition_2.IMBRICATE_BINARY_STORAGE_CAPABILITY_KEY.UPLOAD_FILE);
-    }
-}
-exports.ImbricateBinaryStorageBase = ImbricateBinaryStorageBase;

package/binary-storage/definition.d.ts

@@ -1,11 +0,0 @@
-/**
- * @author WMXPY
- * @namespace BinaryStorage
- * @description Definition
- */
-import type { ImbricateCapabilityRecord } from "../capability/definition";
-export type ImbricateBinaryStorageCapability = ImbricateCapabilityRecord<IMBRICATE_BINARY_STORAGE_CAPABILITY_KEY>;
-export declare enum IMBRICATE_BINARY_STORAGE_CAPABILITY_KEY {
-    UPLOAD_FILE = "imbricate.binary.storage.upload"
-}
-export declare const ImbricateBinaryStorageCapabilityList: IMBRICATE_BINARY_STORAGE_CAPABILITY_KEY[];

package/binary-storage/definition.js

@@ -1,15 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace BinaryStorage
- * @description Definition
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImbricateBinaryStorageCapabilityList = exports.IMBRICATE_BINARY_STORAGE_CAPABILITY_KEY = void 0;
-var IMBRICATE_BINARY_STORAGE_CAPABILITY_KEY;
-(function (IMBRICATE_BINARY_STORAGE_CAPABILITY_KEY) {
-    IMBRICATE_BINARY_STORAGE_CAPABILITY_KEY["UPLOAD_FILE"] = "imbricate.binary.storage.upload";
-})(IMBRICATE_BINARY_STORAGE_CAPABILITY_KEY || (exports.IMBRICATE_BINARY_STORAGE_CAPABILITY_KEY = IMBRICATE_BINARY_STORAGE_CAPABILITY_KEY = {}));
-exports.ImbricateBinaryStorageCapabilityList = [
-    IMBRICATE_BINARY_STORAGE_CAPABILITY_KEY.UPLOAD_FILE,
-];

package/binary-storage/interface.d.ts

@@ -1,26 +0,0 @@
-/**
- * @author WMXPY
- * @namespace BinaryStorage
- * @description Interface
- */
-import { PromiseOr } from "../definition/promise";
-import { ImbricateBinaryStorageCapability } from "./definition";
-export interface IImbricateBinaryStorage {
-    /**
-     * Capabilities of the binary storage
-     */
-    readonly capabilities: ImbricateBinaryStorageCapability;
-    /**
-     * Store a binary file
-     *
-     * @param binary Base64 encoded binary
-     * @param fileName File name
-     */
-    putBinaryBase64(binary: string, fileName: string): PromiseOr<string>;
-    /**
-     * Validate if the binary is a valid base64 to be stored
-     *
-     * @param binary Base64 encoded binary
-     */
-    validateBinaryBase64(binary: string): PromiseOr<boolean>;
-}

package/binary-storage/interface.js

@@ -1,7 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace BinaryStorage
- * @description Interface
- */
-Object.defineProperty(exports, "__esModule", { value: true });

package/capability/builder.d.ts

@@ -1,15 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Capability
- * @description Builder
- */
-import { ImbricateCapability, ImbricateCapabilityKey, ImbricateCapabilityRecord } from "./definition";
-export declare class ImbricateCapabilityBuilder<T extends ImbricateCapabilityKey> {
-    static create<T extends ImbricateCapabilityKey>(list: T[], initialValue: ImbricateCapability): ImbricateCapabilityBuilder<T>;
-    private readonly _capabilities;
-    private constructor();
-    set(key: T, value: ImbricateCapability): this;
-    allow(key: T): this;
-    deny(key: T): this;
-    build(): ImbricateCapabilityRecord<T>;
-}

package/capability/builder.js

@@ -1,37 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace Capability
- * @description Builder
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImbricateCapabilityBuilder = void 0;
-const create_1 = require("./create");
-const definition_1 = require("./definition");
-class ImbricateCapabilityBuilder {
-    static create(list, initialValue) {
-        const capabilities = (0, create_1.createImbricateCapabilityRecord)(list, initialValue);
-        return new ImbricateCapabilityBuilder(capabilities);
-    }
-    constructor(capabilities) {
-        this._capabilities = capabilities;
-    }
-    set(key, value) {
-        this._capabilities[key] = value;
-        return this;
-    }
-    allow(key) {
-        this._capabilities[key] = (0, definition_1.createAllowImbricateCapability)();
-        return this;
-    }
-    deny(key) {
-        this._capabilities[key] = (0, definition_1.createDenyImbricateCapability)();
-        return this;
-    }
-    build() {
-        return Object.keys(this._capabilities).reduce((previous, current) => {
-            return Object.assign(Object.assign({}, previous), { [current]: this._capabilities[current] });
-        }, {});
-    }
-}
-exports.ImbricateCapabilityBuilder = ImbricateCapabilityBuilder;

package/capability/create.d.ts

@@ -1,7 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Capability
- * @description Create
- */
-import type { ImbricateCapability, ImbricateCapabilityKey, ImbricateCapabilityRecord } from "./definition";
-export declare const createImbricateCapabilityRecord: <T extends ImbricateCapabilityKey>(list: T[], initialValue: ImbricateCapability) => ImbricateCapabilityRecord<T>;

package/capability/create.js

@@ -1,16 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace Capability
- * @description Create
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createImbricateCapabilityRecord = void 0;
-const createImbricateCapabilityRecord = (list, initialValue) => {
-    const record = {};
-    for (const key of list) {
-        record[key] = Object.assign({}, initialValue);
-    }
-    return record;
-};
-exports.createImbricateCapabilityRecord = createImbricateCapabilityRecord;

package/capability/definition.d.ts

@@ -1,16 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Capability
- * @description Definition
- */
-export type ImbricateCapabilityKey = string;
-export declare enum IMBRICATE_CAPABILITY_EFFECT {
-    ALLOW = "ALLOW",
-    DENY = "DENY"
-}
-export type ImbricateCapability = {
-    readonly effect: IMBRICATE_CAPABILITY_EFFECT;
-};
-export type ImbricateCapabilityRecord<T extends ImbricateCapabilityKey> = Record<T, ImbricateCapability>;
-export declare const createAllowImbricateCapability: () => ImbricateCapability;
-export declare const createDenyImbricateCapability: () => ImbricateCapability;

package/capability/definition.js

@@ -1,25 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace Capability
- * @description Definition
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDenyImbricateCapability = exports.createAllowImbricateCapability = exports.IMBRICATE_CAPABILITY_EFFECT = void 0;
-var IMBRICATE_CAPABILITY_EFFECT;
-(function (IMBRICATE_CAPABILITY_EFFECT) {
-    IMBRICATE_CAPABILITY_EFFECT["ALLOW"] = "ALLOW";
-    IMBRICATE_CAPABILITY_EFFECT["DENY"] = "DENY";
-})(IMBRICATE_CAPABILITY_EFFECT || (exports.IMBRICATE_CAPABILITY_EFFECT = IMBRICATE_CAPABILITY_EFFECT = {}));
-const createAllowImbricateCapability = () => {
-    return {
-        effect: IMBRICATE_CAPABILITY_EFFECT.ALLOW,
-    };
-};
-exports.createAllowImbricateCapability = createAllowImbricateCapability;
-const createDenyImbricateCapability = () => {
-    return {
-        effect: IMBRICATE_CAPABILITY_EFFECT.DENY,
-    };
-};
-exports.createDenyImbricateCapability = createDenyImbricateCapability;

package/capability/validate.d.ts

@@ -1,19 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Capability
- * @description Validate
- */
-import { IMBRICATE_COLLECTION_CAPABILITY_KEY } from "../collection/definition";
-import type { IImbricateCollection } from "../collection/interface";
-import { IMBRICATE_ORIGIN_CAPABILITY_KEY } from "../origin/definition";
-import { IImbricateOrigin } from "../origin/interface";
-import { IMBRICATE_PAGE_CAPABILITY_KEY } from "../page/definition";
-import { IImbricatePage } from "../page/interface";
-import { IMBRICATE_SCRIPT_CAPABILITY_KEY } from "../script/definition";
-import { IImbricateScript } from "../script/interface";
-import { ImbricateCapability } from "./definition";
-export declare const validateImbricateCapability: <CapabilityRecords extends Record<string, ImbricateCapability>, KeySet extends keyof CapabilityRecords>(capabilities: CapabilityRecords, capability: KeySet) => boolean;
-export declare const validateImbricateOriginCapability: (origin: IImbricateOrigin, capability: IMBRICATE_ORIGIN_CAPABILITY_KEY) => boolean;
-export declare const validateImbricateCollectionCapability: (collection: IImbricateCollection, capability: IMBRICATE_COLLECTION_CAPABILITY_KEY) => boolean;
-export declare const validateImbricatePageCapability: (page: IImbricatePage, capability: IMBRICATE_PAGE_CAPABILITY_KEY) => boolean;
-export declare const validateImbricateScriptCapability: (script: IImbricateScript, capability: IMBRICATE_SCRIPT_CAPABILITY_KEY) => boolean;