@imbricate/core 1.21.0 → 1.24.1

package/binary-storage/base.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @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 ImbricateBaseBinaryStorage 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

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace BinaryStorage
+ * @description Base
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImbricateBaseBinaryStorage = 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 ImbricateBaseBinaryStorage {
+    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.ImbricateBaseBinaryStorage = ImbricateBaseBinaryStorage;

package/binary-storage/definition.d.ts

@@ -3,9 +3,9 @@
  * @namespace BinaryStorage
  * @description Definition
  */
-import { ImbricateCapability } from "../capability/definition";
-export type ImbricateBinaryStorageCapability = Record<IMBRICATE_BINARY_STORAGE_CAPABILITY_KEY, ImbricateCapability>;
+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 createAllAllowImbricateBinaryStorageCapability: () => ImbricateBinaryStorageCapability;
+export declare const ImbricateBinaryStorageCapabilityList: IMBRICATE_BINARY_STORAGE_CAPABILITY_KEY[];

package/binary-storage/definition.js

@@ -5,17 +5,11 @@
  * @description Definition
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createAllAllowImbricateBinaryStorageCapability = exports.IMBRICATE_BINARY_STORAGE_CAPABILITY_KEY = void 0;
-const definition_1 = require("../capability/definition");
+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 = {}));
-const createAllAllowImbricateBinaryStorageCapability = () => {
-    return {
-        [IMBRICATE_BINARY_STORAGE_CAPABILITY_KEY.UPLOAD_FILE]: {
-            effect: definition_1.IMBRICATE_CAPABILITY_EFFECT.ALLOW,
-        },
-    };
-};
-exports.createAllAllowImbricateBinaryStorageCapability = createAllAllowImbricateBinaryStorageCapability;
+exports.ImbricateBinaryStorageCapabilityList = [
+    IMBRICATE_BINARY_STORAGE_CAPABILITY_KEY.UPLOAD_FILE,
+];

package/capability/builder.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @author WMXPY
+ * @namespace Capability
+ * @description Builder
+ */
+import type { 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();
+    build(): ImbricateCapabilityRecord<T>;
+}

package/capability/builder.js

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Capability
+ * @description Builder
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImbricateCapabilityBuilder = void 0;
+const create_1 = require("./create");
+class ImbricateCapabilityBuilder {
+    static create(list, initialValue) {
+        const capabilities = (0, create_1.createImbricateCapabilityRecord)(list, initialValue);
+        return new ImbricateCapabilityBuilder(capabilities);
+    }
+    constructor(capabilities) {
+        this._capabilities = capabilities;
+    }
+    build() {
+        return Object.keys(this._capabilities).map((key) => {
+            return {
+                [key]: this._capabilities[key],
+            };
+        });
+    }
+}
+exports.ImbricateCapabilityBuilder = ImbricateCapabilityBuilder;

package/capability/create.d.ts

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

package/capability/create.js

@@ -0,0 +1,16 @@
+"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

@@ -3,6 +3,7 @@
  * @namespace Capability
  * @description Definition
  */
+export type ImbricateCapabilityKey = string;
 export declare enum IMBRICATE_CAPABILITY_EFFECT {
     ALLOW = "ALLOW",
     DENY = "DENY"
@@ -10,3 +11,6 @@ export declare enum IMBRICATE_CAPABILITY_EFFECT {
 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

@@ -5,9 +5,21 @@
  * @description Definition
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IMBRICATE_CAPABILITY_EFFECT = void 0;
+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

@@ -4,7 +4,7 @@
  * @description Validate
  */
 import { IMBRICATE_COLLECTION_CAPABILITY_KEY } from "../collection/definition";
-import { IImbricateOriginCollection } from "../collection/interface";
+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";
@@ -14,6 +14,6 @@ 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: IImbricateOriginCollection, capability: IMBRICATE_COLLECTION_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;

package/collection/base.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @author WMXPY
+ * @namespace Collection
+ * @description Base
+ */
+import { ImbricateCapabilityBuilder } from "../capability/builder";
+import { ImbricateCapability } from "../capability/definition";
+import type { PromiseOr } from "../definition/promise";
+import type { ImbricatePageMetadata, ImbricatePageSearchResult, ImbricatePageSnapshot } from "../page/definition";
+import type { IImbricatePage } from "../page/interface";
+import type { ImbricatePageQuery, ImbricatePageQueryConfig, ImbricateSearchPageConfig } from "../query/page";
+import { IMBRICATE_COLLECTION_CAPABILITY_KEY, ImbricateCollectionCapability } from "./definition";
+import type { IImbricateCollection } from "./interface";
+export declare abstract class ImbricateCollectionBase implements IImbricateCollection {
+    static buildCapability(initial?: ImbricateCapability): ImbricateCapabilityBuilder<IMBRICATE_COLLECTION_CAPABILITY_KEY>;
+    static allAllowCapability(): ImbricateCollectionCapability;
+    static allDenyCapability(): ImbricateCollectionCapability;
+    abstract readonly collectionName: string;
+    abstract readonly uniqueIdentifier: string;
+    abstract readonly capabilities: ImbricateCollectionCapability;
+    createPage(_directories: string[], _title: string, _initialContent: string): PromiseOr<IImbricatePage>;
+    putPage(_pageMetadata: ImbricatePageMetadata, _content: string): PromiseOr<IImbricatePage>;
+    retitlePage(_identifier: string, _newTitle: string): PromiseOr<void>;
+    deletePage(_identifier: string): PromiseOr<void>;
+    hasPage(_directories: string[], _title: string): PromiseOr<boolean>;
+    getPage(_identifier: string): PromiseOr<IImbricatePage | null>;
+    listPages(_directories: string[], _recursive: boolean): PromiseOr<ImbricatePageSnapshot[]>;
+    listDirectories(_directories: string[]): PromiseOr<string[]>;
+    searchPages(_keyword: string, _config: ImbricateSearchPageConfig): PromiseOr<ImbricatePageSearchResult[]>;
+    queryPages(_query: ImbricatePageQuery, _config: ImbricatePageQueryConfig): PromiseOr<IImbricatePage[]>;
+}

package/collection/base.js

@@ -0,0 +1,54 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Collection
+ * @description Base
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImbricateCollectionBase = 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 ImbricateCollectionBase {
+    static buildCapability(initial = (0, definition_1.createDenyImbricateCapability)()) {
+        return builder_1.ImbricateCapabilityBuilder.create(definition_2.ImbricateCollectionCapabilityList, initial);
+    }
+    static allAllowCapability() {
+        return this.buildCapability((0, definition_1.createAllowImbricateCapability)()).build();
+    }
+    static allDenyCapability() {
+        return this.buildCapability((0, definition_1.createDenyImbricateCapability)()).build();
+    }
+    createPage(_directories, _title, _initialContent) {
+        throw not_implemented_1.ImbricateNotImplemented.create("CreatePage", definition_2.IMBRICATE_COLLECTION_CAPABILITY_KEY.CREATE_PAGE);
+    }
+    putPage(_pageMetadata, _content) {
+        throw not_implemented_1.ImbricateNotImplemented.create("PutPage", definition_2.IMBRICATE_COLLECTION_CAPABILITY_KEY.PUT_PAGE);
+    }
+    retitlePage(_identifier, _newTitle) {
+        throw not_implemented_1.ImbricateNotImplemented.create("RetitlePage", definition_2.IMBRICATE_COLLECTION_CAPABILITY_KEY.RETITLE_PAGE);
+    }
+    deletePage(_identifier) {
+        throw not_implemented_1.ImbricateNotImplemented.create("DeletePage", definition_2.IMBRICATE_COLLECTION_CAPABILITY_KEY.DELETE_PAGE);
+    }
+    hasPage(_directories, _title) {
+        throw not_implemented_1.ImbricateNotImplemented.create("HasPage", definition_2.IMBRICATE_COLLECTION_CAPABILITY_KEY.GET_PAGE);
+    }
+    getPage(_identifier) {
+        throw not_implemented_1.ImbricateNotImplemented.create("GetPage", definition_2.IMBRICATE_COLLECTION_CAPABILITY_KEY.GET_PAGE);
+    }
+    listPages(_directories, _recursive) {
+        throw not_implemented_1.ImbricateNotImplemented.create("ListPages", definition_2.IMBRICATE_COLLECTION_CAPABILITY_KEY.LIST_PAGES);
+    }
+    listDirectories(_directories) {
+        throw not_implemented_1.ImbricateNotImplemented.create("ListDirectories", definition_2.IMBRICATE_COLLECTION_CAPABILITY_KEY.LIST_PAGES);
+    }
+    searchPages(_keyword, _config) {
+        throw not_implemented_1.ImbricateNotImplemented.create("SearchPages", definition_2.IMBRICATE_COLLECTION_CAPABILITY_KEY.LIST_PAGES);
+    }
+    queryPages(_query, _config) {
+        throw not_implemented_1.ImbricateNotImplemented.create("QueryPages", definition_2.IMBRICATE_COLLECTION_CAPABILITY_KEY.LIST_PAGES);
+    }
+}
+exports.ImbricateCollectionBase = ImbricateCollectionBase;

package/collection/definition.d.ts

@@ -3,7 +3,7 @@
  * @namespace Collection
  * @description Definition
  */
-import { ImbricateCapability } from "../capability/definition";
+import type { ImbricateCapability } from "../capability/definition";
 export type ImbricateCollectionCapability = Record<IMBRICATE_COLLECTION_CAPABILITY_KEY, ImbricateCapability>;
 export declare enum IMBRICATE_COLLECTION_CAPABILITY_KEY {
     CREATE_PAGE = "imbricate.collection.page.create",
@@ -13,4 +13,4 @@ export declare enum IMBRICATE_COLLECTION_CAPABILITY_KEY {
     GET_PAGE = "imbricate.collection.page.get",
     LIST_PAGES = "imbricate.collection.page.list"
 }
-export declare const createAllAllowImbricateCollectionCapability: () => ImbricateCollectionCapability;
+export declare const ImbricateCollectionCapabilityList: IMBRICATE_COLLECTION_CAPABILITY_KEY[];

package/collection/definition.js

@@ -5,8 +5,7 @@
  * @description Definition
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createAllAllowImbricateCollectionCapability = exports.IMBRICATE_COLLECTION_CAPABILITY_KEY = void 0;
-const definition_1 = require("../capability/definition");
+exports.ImbricateCollectionCapabilityList = exports.IMBRICATE_COLLECTION_CAPABILITY_KEY = void 0;
 var IMBRICATE_COLLECTION_CAPABILITY_KEY;
 (function (IMBRICATE_COLLECTION_CAPABILITY_KEY) {
     IMBRICATE_COLLECTION_CAPABILITY_KEY["CREATE_PAGE"] = "imbricate.collection.page.create";
@@ -16,26 +15,11 @@ var IMBRICATE_COLLECTION_CAPABILITY_KEY;
     IMBRICATE_COLLECTION_CAPABILITY_KEY["GET_PAGE"] = "imbricate.collection.page.get";
     IMBRICATE_COLLECTION_CAPABILITY_KEY["LIST_PAGES"] = "imbricate.collection.page.list";
 })(IMBRICATE_COLLECTION_CAPABILITY_KEY || (exports.IMBRICATE_COLLECTION_CAPABILITY_KEY = IMBRICATE_COLLECTION_CAPABILITY_KEY = {}));
-const createAllAllowImbricateCollectionCapability = () => {
-    return {
-        [IMBRICATE_COLLECTION_CAPABILITY_KEY.CREATE_PAGE]: {
-            effect: definition_1.IMBRICATE_CAPABILITY_EFFECT.ALLOW,
-        },
-        [IMBRICATE_COLLECTION_CAPABILITY_KEY.PUT_PAGE]: {
-            effect: definition_1.IMBRICATE_CAPABILITY_EFFECT.ALLOW,
-        },
-        [IMBRICATE_COLLECTION_CAPABILITY_KEY.RETITLE_PAGE]: {
-            effect: definition_1.IMBRICATE_CAPABILITY_EFFECT.ALLOW,
-        },
-        [IMBRICATE_COLLECTION_CAPABILITY_KEY.DELETE_PAGE]: {
-            effect: definition_1.IMBRICATE_CAPABILITY_EFFECT.ALLOW,
-        },
-        [IMBRICATE_COLLECTION_CAPABILITY_KEY.GET_PAGE]: {
-            effect: definition_1.IMBRICATE_CAPABILITY_EFFECT.ALLOW,
-        },
-        [IMBRICATE_COLLECTION_CAPABILITY_KEY.LIST_PAGES]: {
-            effect: definition_1.IMBRICATE_CAPABILITY_EFFECT.ALLOW,
-        },
-    };
-};
-exports.createAllAllowImbricateCollectionCapability = createAllAllowImbricateCollectionCapability;
+exports.ImbricateCollectionCapabilityList = [
+    IMBRICATE_COLLECTION_CAPABILITY_KEY.CREATE_PAGE,
+    IMBRICATE_COLLECTION_CAPABILITY_KEY.PUT_PAGE,
+    IMBRICATE_COLLECTION_CAPABILITY_KEY.RETITLE_PAGE,
+    IMBRICATE_COLLECTION_CAPABILITY_KEY.DELETE_PAGE,
+    IMBRICATE_COLLECTION_CAPABILITY_KEY.GET_PAGE,
+    IMBRICATE_COLLECTION_CAPABILITY_KEY.LIST_PAGES,
+];

package/collection/interface.d.ts

@@ -1,14 +1,14 @@
 /**
  * @author WMXPY
- * @namespace Origin_Collection
+ * @namespace Collection
  * @description Interface
  */
-import { PromiseOr } from "../definition/promise";
-import { ImbricatePageMetadata, ImbricatePageSearchResult, ImbricatePageSnapshot } from "../page/definition";
-import { IImbricatePage } from "../page/interface";
-import { ImbricatePageQuery, ImbricatePageQueryConfig, ImbricateSearchPageConfig } from "../query/page";
-import { ImbricateCollectionCapability } from "./definition";
-export interface IImbricateOriginCollection {
+import type { PromiseOr } from "../definition/promise";
+import type { ImbricatePageMetadata, ImbricatePageSearchResult, ImbricatePageSnapshot } from "../page/definition";
+import type { IImbricatePage } from "../page/interface";
+import type { ImbricatePageQuery, ImbricatePageQueryConfig, ImbricateSearchPageConfig } from "../query/page";
+import type { ImbricateCollectionCapability } from "./definition";
+export interface IImbricateCollection {
     readonly collectionName: string;
     readonly uniqueIdentifier: string;
     readonly description?: string;

package/collection/interface.js

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

package/error/not-implemented.d.ts

@@ -4,7 +4,7 @@
  * @description Not Implemented
  */
 import { ImbricateError } from "./imbricate-error";
-export declare class ImbricateNoteImplemented extends ImbricateError {
-    static create(originName: string, capabilityIdentifier: string): ImbricateNoteImplemented;
+export declare class ImbricateNotImplemented extends ImbricateError {
+    static create(feature: string, capabilityIdentifier: string): ImbricateNotImplemented;
     protected constructor(message: string, reason?: any);
 }

package/error/not-implemented.js

@@ -5,15 +5,15 @@
  * @description Not Implemented
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImbricateNoteImplemented = void 0;
+exports.ImbricateNotImplemented = void 0;
 const imbricate_error_1 = require("./imbricate-error");
-class ImbricateNoteImplemented extends imbricate_error_1.ImbricateError {
-    static create(originName, capabilityIdentifier) {
-        return new ImbricateNoteImplemented(`Origin: ${originName} Capability: ${capabilityIdentifier} Not Implemented`);
+class ImbricateNotImplemented extends imbricate_error_1.ImbricateError {
+    static create(feature, capabilityIdentifier) {
+        return new ImbricateNotImplemented(`Feature: [${feature}], which correspond with capability: [${capabilityIdentifier}] is not Implemented`);
     }
     constructor(message, reason) {
-        super(message, "ImbricateNoteImplemented", reason);
-        Object.setPrototypeOf(this, ImbricateNoteImplemented.prototype);
+        super(message, "ImbricateNotImplemented", reason);
+        Object.setPrototypeOf(this, ImbricateNotImplemented.prototype);
     }
 }
-exports.ImbricateNoteImplemented = ImbricateNoteImplemented;
+exports.ImbricateNotImplemented = ImbricateNotImplemented;

package/function/base.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @author WMXPY
+ * @namespace Function
+ * @description Base
+ */
+import { ImbricateCapabilityBuilder } from "../capability/builder";
+import { ImbricateCapability } from "../capability/definition";
+import type { IImbricateOrigin } from "../origin/interface";
+import { IMBRICATE_FUNCTION_CAPABILITY_KEY, ImbricateFunction, ImbricateFunctionCapability } from "./definition";
+import type { IImbricateFunctionManager } from "./interface";
+export declare abstract class ImbricateFunctionManagerBase implements IImbricateFunctionManager {
+    static buildCapability(initial?: ImbricateCapability): ImbricateCapabilityBuilder<IMBRICATE_FUNCTION_CAPABILITY_KEY>;
+    static allAllowCapability(): ImbricateFunctionCapability;
+    static allDenyCapability(): ImbricateFunctionCapability;
+    abstract readonly capabilities: ImbricateFunctionCapability;
+    findSynchronousOriginFunctions(): Array<ImbricateFunction<IImbricateOrigin>>;
+    findAllOriginFunctions(): Array<ImbricateFunction<IImbricateOrigin>>;
+}

package/function/base.js

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Function
+ * @description Base
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImbricateFunctionManagerBase = 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 ImbricateFunctionManagerBase {
+    static buildCapability(initial = (0, definition_1.createDenyImbricateCapability)()) {
+        return builder_1.ImbricateCapabilityBuilder.create(definition_2.ImbricateFunctionCapabilityList, initial);
+    }
+    static allAllowCapability() {
+        return this.buildCapability((0, definition_1.createAllowImbricateCapability)()).build();
+    }
+    static allDenyCapability() {
+        return this.buildCapability((0, definition_1.createDenyImbricateCapability)()).build();
+    }
+    findSynchronousOriginFunctions() {
+        throw not_implemented_1.ImbricateNotImplemented.create("FindSynchronousOriginFunctions", definition_2.IMBRICATE_FUNCTION_CAPABILITY_KEY.FIND_ORIGIN_FUNCTIONS);
+    }
+    findAllOriginFunctions() {
+        throw not_implemented_1.ImbricateNotImplemented.create("FindAllOriginFunctions", definition_2.IMBRICATE_FUNCTION_CAPABILITY_KEY.FIND_ORIGIN_FUNCTIONS);
+    }
+}
+exports.ImbricateFunctionManagerBase = ImbricateFunctionManagerBase;

package/function/definition.d.ts

@@ -15,4 +15,5 @@ export type ImbricateFunctionCapability = Record<IMBRICATE_FUNCTION_CAPABILITY_K
 export declare enum IMBRICATE_FUNCTION_CAPABILITY_KEY {
     FIND_ORIGIN_FUNCTIONS = "imbricate.function.origin.find"
 }
+export declare const ImbricateFunctionCapabilityList: IMBRICATE_FUNCTION_CAPABILITY_KEY[];
 export declare const createAllAllowImbricateFunctionCapability: () => ImbricateFunctionCapability;

package/function/definition.js

@@ -5,12 +5,15 @@
  * @description Definition
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createAllAllowImbricateFunctionCapability = exports.IMBRICATE_FUNCTION_CAPABILITY_KEY = void 0;
+exports.createAllAllowImbricateFunctionCapability = exports.ImbricateFunctionCapabilityList = exports.IMBRICATE_FUNCTION_CAPABILITY_KEY = void 0;
 const definition_1 = require("../capability/definition");
 var IMBRICATE_FUNCTION_CAPABILITY_KEY;
 (function (IMBRICATE_FUNCTION_CAPABILITY_KEY) {
     IMBRICATE_FUNCTION_CAPABILITY_KEY["FIND_ORIGIN_FUNCTIONS"] = "imbricate.function.origin.find";
 })(IMBRICATE_FUNCTION_CAPABILITY_KEY || (exports.IMBRICATE_FUNCTION_CAPABILITY_KEY = IMBRICATE_FUNCTION_CAPABILITY_KEY = {}));
+exports.ImbricateFunctionCapabilityList = [
+    IMBRICATE_FUNCTION_CAPABILITY_KEY.FIND_ORIGIN_FUNCTIONS,
+];
 const createAllAllowImbricateFunctionCapability = () => {
     return {
         [IMBRICATE_FUNCTION_CAPABILITY_KEY.FIND_ORIGIN_FUNCTIONS]: {

package/index.d.ts

@@ -2,10 +2,14 @@
  * @author WMXPY
  * @description Index
  */
+export * from "./binary-storage/base";
 export * from "./binary-storage/definition";
 export * from "./binary-storage/interface";
+export * from "./capability/builder";
+export * from "./capability/create";
 export * from "./capability/definition";
 export * from "./capability/validate";
+export * from "./collection/base";
 export * from "./collection/definition";
 export * from "./collection/interface";
 export * from "./collection/least-common-identifier";
@@ -13,10 +17,13 @@ export * from "./definition/listable";
 export * from "./definition/promise";
 export * from "./error/imbricate-error";
 export * from "./error/not-implemented";
+export * from "./function/base";
 export * from "./function/definition";
 export * from "./function/interface";
+export * from "./origin/base";
 export * from "./origin/definition";
 export * from "./origin/interface";
+export * from "./page/base";
 export * from "./page/definition";
 export * from "./page/interface";
 export * from "./query/definition";
@@ -28,9 +35,11 @@ export * from "./sandbox/definition/implementation";
 export * from "./sandbox/feature/builder";
 export * from "./sandbox/feature/feature";
 export * from "./sandbox/sandbox";
+export * from "./script/base";
 export * from "./script/definition";
 export * from "./script/interface";
 export * from "./search/prefix";
 export * from "./search/snippet";
+export * from "./trash/base";
 export * from "./trash/definition";
 export * from "./trash/interface";

package/index.js

@@ -18,10 +18,14 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./binary-storage/base"), exports);
 __exportStar(require("./binary-storage/definition"), exports);
 __exportStar(require("./binary-storage/interface"), exports);
+__exportStar(require("./capability/builder"), exports);
+__exportStar(require("./capability/create"), exports);
 __exportStar(require("./capability/definition"), exports);
 __exportStar(require("./capability/validate"), exports);
+__exportStar(require("./collection/base"), exports);
 __exportStar(require("./collection/definition"), exports);
 __exportStar(require("./collection/interface"), exports);
 __exportStar(require("./collection/least-common-identifier"), exports);
@@ -29,10 +33,13 @@ __exportStar(require("./definition/listable"), exports);
 __exportStar(require("./definition/promise"), exports);
 __exportStar(require("./error/imbricate-error"), exports);
 __exportStar(require("./error/not-implemented"), exports);
+__exportStar(require("./function/base"), exports);
 __exportStar(require("./function/definition"), exports);
 __exportStar(require("./function/interface"), exports);
+__exportStar(require("./origin/base"), exports);
 __exportStar(require("./origin/definition"), exports);
 __exportStar(require("./origin/interface"), exports);
+__exportStar(require("./page/base"), exports);
 __exportStar(require("./page/definition"), exports);
 __exportStar(require("./page/interface"), exports);
 __exportStar(require("./query/definition"), exports);
@@ -44,9 +51,11 @@ __exportStar(require("./sandbox/definition/implementation"), exports);
 __exportStar(require("./sandbox/feature/builder"), exports);
 __exportStar(require("./sandbox/feature/feature"), exports);
 __exportStar(require("./sandbox/sandbox"), exports);
+__exportStar(require("./script/base"), exports);
 __exportStar(require("./script/definition"), exports);
 __exportStar(require("./script/interface"), exports);
 __exportStar(require("./search/prefix"), exports);
 __exportStar(require("./search/snippet"), exports);
+__exportStar(require("./trash/base"), exports);
 __exportStar(require("./trash/definition"), exports);
 __exportStar(require("./trash/interface"), exports);

package/origin/base.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @author WMXPY
+ * @namespace Origin
+ * @description Base
+ */
+import type { IImbricateBinaryStorage } from "../binary-storage/interface";
+import { ImbricateCapabilityBuilder } from "../capability/builder";
+import { ImbricateCapability } from "../capability/definition";
+import type { IImbricateCollection } from "../collection/interface";
+import type { PromiseOr } from "../definition/promise";
+import type { IImbricateFunctionManager } from "../function/interface";
+import type { IImbricateOrigin } from "../origin/interface";
+import { ImbricateScriptQuery, ImbricateScriptQueryConfig, ImbricateSearchScriptConfig } from "../query/script";
+import { ImbricateScriptMetadata, ImbricateScriptSnapshot } from "../script/definition";
+import type { IImbricateScript } from "../script/interface";
+import { IMBRICATE_ORIGIN_CAPABILITY_KEY, ImbricateOriginCapability, ImbricateOriginMetadata } from "./definition";
+export declare abstract class ImbricateOriginBase implements IImbricateOrigin {
+    static buildCapability(initial?: ImbricateCapability): ImbricateCapabilityBuilder<IMBRICATE_ORIGIN_CAPABILITY_KEY>;
+    static allAllowCapability(): ImbricateOriginCapability;
+    static allDenyCapability(): ImbricateOriginCapability;
+    abstract readonly originType: string;
+    abstract readonly uniqueIdentifier: string;
+    abstract readonly metadata: ImbricateOriginMetadata;
+    abstract readonly payloads: Record<string, any>;
+    abstract readonly capabilities: ImbricateOriginCapability;
+    getFunctionManager(): IImbricateFunctionManager;
+    getBinaryStorage(): IImbricateBinaryStorage;
+    createCollection(_collectionName: string, _description?: string): PromiseOr<IImbricateCollection>;
+    renameCollection(_collectionUniqueIdentifier: string, _newCollectionName: string): PromiseOr<void>;
+    deleteCollection(_collectionUniqueIdentifier: string): PromiseOr<void>;
+    hasCollection(_collectionName: string): PromiseOr<boolean>;
+    findCollection(_collectionName: string): PromiseOr<IImbricateCollection | null>;
+    getCollection(_collectionUniqueIdentifier: string): PromiseOr<IImbricateCollection | null>;
+    listCollections(): PromiseOr<IImbricateCollection[]>;
+    createScript(_scriptName: string, _initialScript: string, _description?: string): PromiseOr<IImbricateScript>;
+    putScript(_scriptMetadata: ImbricateScriptMetadata, _script: string): PromiseOr<IImbricateScript>;
+    renameScript(_identifier: string, _newScriptName: string): PromiseOr<void>;
+    deleteScript(_identifier: string): PromiseOr<void>;
+    hasScript(_scriptName: string): PromiseOr<boolean>;
+    getScript(_identifier: string): PromiseOr<IImbricateScript | null>;
+    listScripts(): PromiseOr<ImbricateScriptSnapshot[]>;
+    searchScripts(_keyword: string, _config: ImbricateSearchScriptConfig): PromiseOr<any[]>;
+    queryScripts(_query: ImbricateScriptQuery, _config: ImbricateScriptQueryConfig): PromiseOr<IImbricateScript[]>;
+}

package/origin/base.js

@@ -0,0 +1,78 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Origin
+ * @description Base
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImbricateOriginBase = 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 ImbricateOriginBase {
+    static buildCapability(initial = (0, definition_1.createDenyImbricateCapability)()) {
+        return builder_1.ImbricateCapabilityBuilder.create(definition_2.ImbricateOriginCapabilityList, initial);
+    }
+    static allAllowCapability() {
+        return this.buildCapability((0, definition_1.createAllowImbricateCapability)()).build();
+    }
+    static allDenyCapability() {
+        return this.buildCapability((0, definition_1.createDenyImbricateCapability)()).build();
+    }
+    getFunctionManager() {
+        throw not_implemented_1.ImbricateNotImplemented.create("GetFunctionManager", definition_2.IMBRICATE_ORIGIN_CAPABILITY_KEY.ORIGIN_FUNCTION);
+    }
+    getBinaryStorage() {
+        throw not_implemented_1.ImbricateNotImplemented.create("GetBinaryStorage", definition_2.IMBRICATE_ORIGIN_CAPABILITY_KEY.ORIGIN_BINARY_STORAGE);
+    }
+    createCollection(_collectionName, _description) {
+        throw not_implemented_1.ImbricateNotImplemented.create("CreateCollection", definition_2.IMBRICATE_ORIGIN_CAPABILITY_KEY.CREATE_COLLECTION);
+    }
+    renameCollection(_collectionUniqueIdentifier, _newCollectionName) {
+        throw not_implemented_1.ImbricateNotImplemented.create("RenameCollection", definition_2.IMBRICATE_ORIGIN_CAPABILITY_KEY.RENAME_COLLECTION);
+    }
+    deleteCollection(_collectionUniqueIdentifier) {
+        throw not_implemented_1.ImbricateNotImplemented.create("DeleteCollection", definition_2.IMBRICATE_ORIGIN_CAPABILITY_KEY.DELETE_COLLECTION);
+    }
+    hasCollection(_collectionName) {
+        throw not_implemented_1.ImbricateNotImplemented.create("HasCollection", definition_2.IMBRICATE_ORIGIN_CAPABILITY_KEY.LIST_COLLECTIONS);
+    }
+    findCollection(_collectionName) {
+        throw not_implemented_1.ImbricateNotImplemented.create("FindCollection", definition_2.IMBRICATE_ORIGIN_CAPABILITY_KEY.LIST_COLLECTIONS);
+    }
+    getCollection(_collectionUniqueIdentifier) {
+        throw not_implemented_1.ImbricateNotImplemented.create("GetCollection", definition_2.IMBRICATE_ORIGIN_CAPABILITY_KEY.GET_COLLECTION);
+    }
+    listCollections() {
+        throw not_implemented_1.ImbricateNotImplemented.create("ListCollections", definition_2.IMBRICATE_ORIGIN_CAPABILITY_KEY.LIST_COLLECTIONS);
+    }
+    createScript(_scriptName, _initialScript, _description) {
+        throw not_implemented_1.ImbricateNotImplemented.create("CreateScript", definition_2.IMBRICATE_ORIGIN_CAPABILITY_KEY.CREATE_SCRIPT);
+    }
+    putScript(_scriptMetadata, _script) {
+        throw not_implemented_1.ImbricateNotImplemented.create("PutScript", definition_2.IMBRICATE_ORIGIN_CAPABILITY_KEY.PUT_SCRIPT);
+    }
+    renameScript(_identifier, _newScriptName) {
+        throw not_implemented_1.ImbricateNotImplemented.create("RenameScript", definition_2.IMBRICATE_ORIGIN_CAPABILITY_KEY.RENAME_SCRIPT);
+    }
+    deleteScript(_identifier) {
+        throw not_implemented_1.ImbricateNotImplemented.create("DeleteScript", definition_2.IMBRICATE_ORIGIN_CAPABILITY_KEY.DELETE_SCRIPT);
+    }
+    hasScript(_scriptName) {
+        throw not_implemented_1.ImbricateNotImplemented.create("HasScript", definition_2.IMBRICATE_ORIGIN_CAPABILITY_KEY.LIST_SCRIPTS);
+    }
+    getScript(_identifier) {
+        throw not_implemented_1.ImbricateNotImplemented.create("GetScript", definition_2.IMBRICATE_ORIGIN_CAPABILITY_KEY.GET_SCRIPT);
+    }
+    listScripts() {
+        throw not_implemented_1.ImbricateNotImplemented.create("ListScripts", definition_2.IMBRICATE_ORIGIN_CAPABILITY_KEY.LIST_SCRIPTS);
+    }
+    searchScripts(_keyword, _config) {
+        throw not_implemented_1.ImbricateNotImplemented.create("SearchScripts", definition_2.IMBRICATE_ORIGIN_CAPABILITY_KEY.LIST_SCRIPTS);
+    }
+    queryScripts(_query, _config) {
+        throw not_implemented_1.ImbricateNotImplemented.create("QueryScripts", definition_2.IMBRICATE_ORIGIN_CAPABILITY_KEY.LIST_SCRIPTS);
+    }
+}
+exports.ImbricateOriginBase = ImbricateOriginBase;

package/origin/definition.d.ts

@@ -29,4 +29,5 @@ export declare enum IMBRICATE_ORIGIN_CAPABILITY_KEY {
     GET_SCRIPT = "imbricate.origin.script.get",
     LIST_SCRIPTS = "imbricate.origin.script.list"
 }
+export declare const ImbricateOriginCapabilityList: IMBRICATE_ORIGIN_CAPABILITY_KEY[];
 export declare const createAllAllowImbricateOriginCapability: () => ImbricateOriginCapability;

package/origin/definition.js

@@ -5,7 +5,7 @@
  * @description Definition
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createAllAllowImbricateOriginCapability = exports.IMBRICATE_ORIGIN_CAPABILITY_KEY = exports.IMBRICATE_DIGEST_ALGORITHM = void 0;
+exports.createAllAllowImbricateOriginCapability = exports.ImbricateOriginCapabilityList = exports.IMBRICATE_ORIGIN_CAPABILITY_KEY = exports.IMBRICATE_DIGEST_ALGORITHM = void 0;
 const definition_1 = require("../capability/definition");
 var IMBRICATE_DIGEST_ALGORITHM;
 (function (IMBRICATE_DIGEST_ALGORITHM) {
@@ -30,6 +30,22 @@ var IMBRICATE_ORIGIN_CAPABILITY_KEY;
     IMBRICATE_ORIGIN_CAPABILITY_KEY["GET_SCRIPT"] = "imbricate.origin.script.get";
     IMBRICATE_ORIGIN_CAPABILITY_KEY["LIST_SCRIPTS"] = "imbricate.origin.script.list";
 })(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.CREATE_COLLECTION,
+    IMBRICATE_ORIGIN_CAPABILITY_KEY.RENAME_COLLECTION,
+    IMBRICATE_ORIGIN_CAPABILITY_KEY.DELETE_COLLECTION,
+    IMBRICATE_ORIGIN_CAPABILITY_KEY.GET_COLLECTION,
+    IMBRICATE_ORIGIN_CAPABILITY_KEY.LIST_COLLECTIONS,
+    IMBRICATE_ORIGIN_CAPABILITY_KEY.CREATE_SCRIPT,
+    IMBRICATE_ORIGIN_CAPABILITY_KEY.PUT_SCRIPT,
+    IMBRICATE_ORIGIN_CAPABILITY_KEY.RENAME_SCRIPT,
+    IMBRICATE_ORIGIN_CAPABILITY_KEY.DELETE_SCRIPT,
+    IMBRICATE_ORIGIN_CAPABILITY_KEY.GET_SCRIPT,
+    IMBRICATE_ORIGIN_CAPABILITY_KEY.LIST_SCRIPTS,
+];
 const createAllAllowImbricateOriginCapability = () => {
     return {
         [IMBRICATE_ORIGIN_CAPABILITY_KEY.ORIGIN_FUNCTION]: {

package/origin/interface.d.ts

@@ -4,7 +4,7 @@
  * @description Interface
  */
 import { IImbricateBinaryStorage } from "../binary-storage/interface";
-import { IImbricateOriginCollection } from "../collection/interface";
+import type { IImbricateCollection } from "../collection/interface";
 import { PromiseOr } from "../definition/promise";
 import { IImbricateFunctionManager } from "../function/interface";
 import { ImbricateScriptQuery, ImbricateScriptQueryConfig, ImbricateSearchScriptConfig } from "../query/script";
@@ -37,7 +37,7 @@ export interface IImbricateOrigin {
      *
      * @returns Function manager
      */
-    getFunctionManger(): IImbricateFunctionManager;
+    getFunctionManager(): IImbricateFunctionManager;
     /**
      * Get binary storage
      *
@@ -52,13 +52,13 @@ export interface IImbricateOrigin {
      *
      * @returns Created collection
      */
-    createCollection(collectionName: string, description?: string): PromiseOr<IImbricateOriginCollection>;
+    createCollection(collectionName: string, description?: string): PromiseOr<IImbricateCollection>;
     renameCollection(collectionUniqueIdentifier: string, newCollectionName: string): PromiseOr<void>;
     deleteCollection(collectionUniqueIdentifier: string): PromiseOr<void>;
     hasCollection(collectionName: string): PromiseOr<boolean>;
-    findCollection(collectionName: string): PromiseOr<IImbricateOriginCollection | null>;
-    getCollection(collectionUniqueIdentifier: string): PromiseOr<IImbricateOriginCollection | null>;
-    listCollections(): PromiseOr<IImbricateOriginCollection[]>;
+    findCollection(collectionName: string): PromiseOr<IImbricateCollection | null>;
+    getCollection(collectionUniqueIdentifier: string): PromiseOr<IImbricateCollection | null>;
+    listCollections(): PromiseOr<IImbricateCollection[]>;
     /**
      * Create a script
      *

package/package.json

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

package/page/base.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @author WMXPY
+ * @namespace Page
+ * @description Base
+ */
+import { ImbricateCapabilityBuilder } from "../capability/builder";
+import { ImbricateCapability } from "../capability/definition";
+import type { PromiseOr } from "../definition/promise";
+import { IMBRICATE_PAGE_CAPABILITY_KEY, ImbricatePageCapability, ImbricatePageHistoryRecord } from "./definition";
+import type { IImbricatePage } from "./interface";
+export declare abstract class ImbricatePageBase implements IImbricatePage {
+    static buildCapability(initial?: ImbricateCapability): ImbricateCapabilityBuilder<IMBRICATE_PAGE_CAPABILITY_KEY>;
+    static allAllowCapability(): ImbricatePageCapability;
+    static allDenyCapability(): ImbricatePageCapability;
+    abstract readonly title: string;
+    abstract readonly directories: string[];
+    abstract readonly identifier: string;
+    abstract readonly digest: string;
+    abstract readonly historyRecords: ImbricatePageHistoryRecord[];
+    abstract readonly description?: string;
+    abstract readonly createdAt: Date;
+    abstract readonly updatedAt: Date;
+    abstract readonly capabilities: ImbricatePageCapability;
+    readContent(): PromiseOr<string>;
+    writeContent(_content: string): PromiseOr<void>;
+    readAttributes(): PromiseOr<Record<string, string>>;
+    writeAttribute(_key: string, _value: string): PromiseOr<void>;
+    refreshUpdateMetadata(_updatedAt: Date, _digest: string): PromiseOr<void>;
+    refreshUpdatedAt(_updatedAt: Date): PromiseOr<void>;
+    refreshDigest(_digest: string): PromiseOr<void>;
+    addHistoryRecord(_record: ImbricatePageHistoryRecord): PromiseOr<void>;
+}

package/page/base.js

@@ -0,0 +1,48 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Page
+ * @description Base
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImbricatePageBase = 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 ImbricatePageBase {
+    static buildCapability(initial = (0, definition_1.createDenyImbricateCapability)()) {
+        return builder_1.ImbricateCapabilityBuilder.create(definition_2.ImbricatePageCapabilityList, initial);
+    }
+    static allAllowCapability() {
+        return this.buildCapability((0, definition_1.createAllowImbricateCapability)()).build();
+    }
+    static allDenyCapability() {
+        return this.buildCapability((0, definition_1.createDenyImbricateCapability)()).build();
+    }
+    readContent() {
+        throw not_implemented_1.ImbricateNotImplemented.create("ReadContent", definition_2.IMBRICATE_PAGE_CAPABILITY_KEY.READ);
+    }
+    writeContent(_content) {
+        throw not_implemented_1.ImbricateNotImplemented.create("WriteContent", definition_2.IMBRICATE_PAGE_CAPABILITY_KEY.WRITE);
+    }
+    readAttributes() {
+        throw not_implemented_1.ImbricateNotImplemented.create("ReadAttributes", definition_2.IMBRICATE_PAGE_CAPABILITY_KEY.READ_ATTRIBUTE);
+    }
+    writeAttribute(_key, _value) {
+        throw not_implemented_1.ImbricateNotImplemented.create("WriteAttribute", definition_2.IMBRICATE_PAGE_CAPABILITY_KEY.WRITE_ATTRIBUTE);
+    }
+    refreshUpdateMetadata(_updatedAt, _digest) {
+        throw not_implemented_1.ImbricateNotImplemented.create("RefreshUpdateMetadata", definition_2.IMBRICATE_PAGE_CAPABILITY_KEY.UPDATE_METADATA);
+    }
+    refreshUpdatedAt(_updatedAt) {
+        throw not_implemented_1.ImbricateNotImplemented.create("RefreshUpdatedAt", definition_2.IMBRICATE_PAGE_CAPABILITY_KEY.UPDATE_METADATA);
+    }
+    refreshDigest(_digest) {
+        throw not_implemented_1.ImbricateNotImplemented.create("RefreshDigest", definition_2.IMBRICATE_PAGE_CAPABILITY_KEY.UPDATE_METADATA);
+    }
+    addHistoryRecord(_record) {
+        throw not_implemented_1.ImbricateNotImplemented.create("AddHistoryRecord", definition_2.IMBRICATE_PAGE_CAPABILITY_KEY.UPDATE_HISTORY_RECORD);
+    }
+}
+exports.ImbricatePageBase = ImbricatePageBase;

package/page/definition.d.ts

@@ -33,4 +33,5 @@ export declare enum IMBRICATE_PAGE_CAPABILITY_KEY {
     UPDATE_METADATA = "imbricate.page.metadata.update",
     UPDATE_HISTORY_RECORD = "imbricate.page.history.update"
 }
+export declare const ImbricatePageCapabilityList: IMBRICATE_PAGE_CAPABILITY_KEY[];
 export declare const createAllAllowImbricatePageCapability: () => ImbricatePageCapability;

package/page/definition.js

@@ -5,7 +5,7 @@
  * @description Definition
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createAllAllowImbricatePageCapability = exports.IMBRICATE_PAGE_CAPABILITY_KEY = void 0;
+exports.createAllAllowImbricatePageCapability = exports.ImbricatePageCapabilityList = exports.IMBRICATE_PAGE_CAPABILITY_KEY = void 0;
 const definition_1 = require("../capability/definition");
 var IMBRICATE_PAGE_CAPABILITY_KEY;
 (function (IMBRICATE_PAGE_CAPABILITY_KEY) {
@@ -16,6 +16,14 @@ var IMBRICATE_PAGE_CAPABILITY_KEY;
     IMBRICATE_PAGE_CAPABILITY_KEY["UPDATE_METADATA"] = "imbricate.page.metadata.update";
     IMBRICATE_PAGE_CAPABILITY_KEY["UPDATE_HISTORY_RECORD"] = "imbricate.page.history.update";
 })(IMBRICATE_PAGE_CAPABILITY_KEY || (exports.IMBRICATE_PAGE_CAPABILITY_KEY = IMBRICATE_PAGE_CAPABILITY_KEY = {}));
+exports.ImbricatePageCapabilityList = [
+    IMBRICATE_PAGE_CAPABILITY_KEY.READ,
+    IMBRICATE_PAGE_CAPABILITY_KEY.WRITE,
+    IMBRICATE_PAGE_CAPABILITY_KEY.READ_ATTRIBUTE,
+    IMBRICATE_PAGE_CAPABILITY_KEY.WRITE_ATTRIBUTE,
+    IMBRICATE_PAGE_CAPABILITY_KEY.UPDATE_METADATA,
+    IMBRICATE_PAGE_CAPABILITY_KEY.UPDATE_HISTORY_RECORD,
+];
 const createAllAllowImbricatePageCapability = () => {
     return {
         [IMBRICATE_PAGE_CAPABILITY_KEY.READ]: {

package/script/base.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @author WMXPY
+ * @namespace Script
+ * @description Base
+ */
+import type { MarkedResult } from "@sudoo/marked";
+import { ImbricateCapabilityBuilder } from "../capability/builder";
+import { ImbricateCapability } from "../capability/definition";
+import type { PromiseOr } from "../definition/promise";
+import type { SandboxExecuteConfig, SandboxExecuteParameter } from "../sandbox/definition/config";
+import type { SandboxFeature } from "../sandbox/feature/feature";
+import { IMBRICATE_SCRIPT_CAPABILITY_KEY, ImbricateScriptAttributes, ImbricateScriptCapability, ImbricateScriptHistoryRecord } from "./definition";
+import type { IImbricateScript } from "./interface";
+export declare abstract class ImbricateScriptBase implements IImbricateScript {
+    static buildCapability(initial?: ImbricateCapability): ImbricateCapabilityBuilder<IMBRICATE_SCRIPT_CAPABILITY_KEY>;
+    static allAllowCapability(): ImbricateScriptCapability;
+    static allDenyCapability(): ImbricateScriptCapability;
+    abstract readonly scriptName: string;
+    abstract readonly identifier: string;
+    abstract readonly digest: string;
+    abstract readonly historyRecords: ImbricateScriptHistoryRecord[];
+    abstract readonly description?: string;
+    abstract readonly createdAt: Date;
+    abstract readonly updatedAt: Date;
+    abstract readonly capabilities: ImbricateScriptCapability;
+    readScript(): PromiseOr<string>;
+    writeScript(_script: string): PromiseOr<void>;
+    readAttributes(): PromiseOr<ImbricateScriptAttributes>;
+    writeAttribute(_key: string, _value: string): PromiseOr<void>;
+    refreshUpdateMetadata(_updatedAt: Date, _digest: string): PromiseOr<void>;
+    refreshUpdatedAt(_updatedAt: Date): PromiseOr<void>;
+    refreshDigest(_digest: string): PromiseOr<void>;
+    addHistoryRecord(_record: ImbricateScriptHistoryRecord): PromiseOr<void>;
+    execute(_features: SandboxFeature[], _config: SandboxExecuteConfig, _parameter: SandboxExecuteParameter): PromiseOr<MarkedResult>;
+}

package/script/base.js

@@ -0,0 +1,51 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Script
+ * @description Base
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImbricateScriptBase = 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 ImbricateScriptBase {
+    static buildCapability(initial = (0, definition_1.createDenyImbricateCapability)()) {
+        return builder_1.ImbricateCapabilityBuilder.create(definition_2.ImbricateScriptCapabilityList, initial);
+    }
+    static allAllowCapability() {
+        return this.buildCapability((0, definition_1.createAllowImbricateCapability)()).build();
+    }
+    static allDenyCapability() {
+        return this.buildCapability((0, definition_1.createDenyImbricateCapability)()).build();
+    }
+    readScript() {
+        throw not_implemented_1.ImbricateNotImplemented.create("ReadScript", definition_2.IMBRICATE_SCRIPT_CAPABILITY_KEY.READ);
+    }
+    writeScript(_script) {
+        throw not_implemented_1.ImbricateNotImplemented.create("WriteScript", definition_2.IMBRICATE_SCRIPT_CAPABILITY_KEY.WRITE);
+    }
+    readAttributes() {
+        throw not_implemented_1.ImbricateNotImplemented.create("ReadAttributes", definition_2.IMBRICATE_SCRIPT_CAPABILITY_KEY.READ_ATTRIBUTE);
+    }
+    writeAttribute(_key, _value) {
+        throw not_implemented_1.ImbricateNotImplemented.create("WriteAttribute", definition_2.IMBRICATE_SCRIPT_CAPABILITY_KEY.WRITE_ATTRIBUTE);
+    }
+    refreshUpdateMetadata(_updatedAt, _digest) {
+        throw not_implemented_1.ImbricateNotImplemented.create("RefreshUpdateMetadata", definition_2.IMBRICATE_SCRIPT_CAPABILITY_KEY.UPDATE_METADATA);
+    }
+    refreshUpdatedAt(_updatedAt) {
+        throw not_implemented_1.ImbricateNotImplemented.create("RefreshUpdatedAt", definition_2.IMBRICATE_SCRIPT_CAPABILITY_KEY.UPDATE_METADATA);
+    }
+    refreshDigest(_digest) {
+        throw not_implemented_1.ImbricateNotImplemented.create("RefreshDigest", definition_2.IMBRICATE_SCRIPT_CAPABILITY_KEY.UPDATE_METADATA);
+    }
+    addHistoryRecord(_record) {
+        throw not_implemented_1.ImbricateNotImplemented.create("AddHistoryRecord", definition_2.IMBRICATE_SCRIPT_CAPABILITY_KEY.UPDATE_HISTORY_RECORD);
+    }
+    execute(_features, _config, _parameter) {
+        throw not_implemented_1.ImbricateNotImplemented.create("Execute", definition_2.IMBRICATE_SCRIPT_CAPABILITY_KEY.EXECUTE);
+    }
+}
+exports.ImbricateScriptBase = ImbricateScriptBase;

package/script/definition.d.ts

@@ -33,4 +33,5 @@ export declare enum IMBRICATE_SCRIPT_CAPABILITY_KEY {
     UPDATE_HISTORY_RECORD = "imbricate.script.history.update",
     EXECUTE = "imbricate.script.execute"
 }
+export declare const ImbricateScriptCapabilityList: IMBRICATE_SCRIPT_CAPABILITY_KEY[];
 export declare const createAllAllowImbricateScriptCapability: () => ImbricateScriptCapability;

package/script/definition.js

@@ -5,7 +5,7 @@
  * @description Definition
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createAllAllowImbricateScriptCapability = exports.IMBRICATE_SCRIPT_CAPABILITY_KEY = void 0;
+exports.createAllAllowImbricateScriptCapability = exports.ImbricateScriptCapabilityList = exports.IMBRICATE_SCRIPT_CAPABILITY_KEY = void 0;
 const definition_1 = require("../capability/definition");
 var IMBRICATE_SCRIPT_CAPABILITY_KEY;
 (function (IMBRICATE_SCRIPT_CAPABILITY_KEY) {
@@ -17,6 +17,15 @@ var IMBRICATE_SCRIPT_CAPABILITY_KEY;
     IMBRICATE_SCRIPT_CAPABILITY_KEY["UPDATE_HISTORY_RECORD"] = "imbricate.script.history.update";
     IMBRICATE_SCRIPT_CAPABILITY_KEY["EXECUTE"] = "imbricate.script.execute";
 })(IMBRICATE_SCRIPT_CAPABILITY_KEY || (exports.IMBRICATE_SCRIPT_CAPABILITY_KEY = IMBRICATE_SCRIPT_CAPABILITY_KEY = {}));
+exports.ImbricateScriptCapabilityList = [
+    IMBRICATE_SCRIPT_CAPABILITY_KEY.READ,
+    IMBRICATE_SCRIPT_CAPABILITY_KEY.WRITE,
+    IMBRICATE_SCRIPT_CAPABILITY_KEY.READ_ATTRIBUTE,
+    IMBRICATE_SCRIPT_CAPABILITY_KEY.WRITE_ATTRIBUTE,
+    IMBRICATE_SCRIPT_CAPABILITY_KEY.UPDATE_METADATA,
+    IMBRICATE_SCRIPT_CAPABILITY_KEY.UPDATE_HISTORY_RECORD,
+    IMBRICATE_SCRIPT_CAPABILITY_KEY.EXECUTE,
+];
 const createAllAllowImbricateScriptCapability = () => {
     return {
         [IMBRICATE_SCRIPT_CAPABILITY_KEY.READ]: {

package/trash/base.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @author WMXPY
+ * @namespace Trash
+ * @description Base
+ */
+import { ImbricateCapabilityBuilder } from "../capability/builder";
+import { ImbricateCapability } from "../capability/definition";
+import type { PromiseOr } from "../definition/promise";
+import { IMBRICATE_TRASH_STASH_CAPABILITY_KEY, ImbricateTrashStashCapability, ImbricateVacantPage, ImbricateVacantScript } from "./definition";
+import type { IImbricateTrashStash } from "./interface";
+export declare abstract class ImbricateTrashStashBase implements IImbricateTrashStash {
+    static buildCapability(initial?: ImbricateCapability): ImbricateCapabilityBuilder<IMBRICATE_TRASH_STASH_CAPABILITY_KEY>;
+    static allAllowCapability(): ImbricateTrashStashCapability;
+    static allDenyCapability(): ImbricateTrashStashCapability;
+    abstract readonly capabilities: ImbricateTrashStashCapability;
+    tossPage(_page: ImbricateVacantPage): PromiseOr<void>;
+    retrievePage(_collectionUniqueIdentifier: string, _pageIdentifier: string): PromiseOr<ImbricateVacantPage | null>;
+    tossScript(_script: ImbricateVacantScript): PromiseOr<void>;
+    retrieveScript(_scriptIdentifier: string): PromiseOr<ImbricateVacantScript | null>;
+}

package/trash/base.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Trash
+ * @description Base
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImbricateTrashStashBase = 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 ImbricateTrashStashBase {
+    static buildCapability(initial = (0, definition_1.createDenyImbricateCapability)()) {
+        return builder_1.ImbricateCapabilityBuilder.create(definition_2.ImbricateTrashStashCapabilityList, initial);
+    }
+    static allAllowCapability() {
+        return this.buildCapability((0, definition_1.createAllowImbricateCapability)()).build();
+    }
+    static allDenyCapability() {
+        return this.buildCapability((0, definition_1.createDenyImbricateCapability)()).build();
+    }
+    tossPage(_page) {
+        throw not_implemented_1.ImbricateNotImplemented.create("TossPage", definition_2.IMBRICATE_TRASH_STASH_CAPABILITY_KEY.TOSS_PAGE);
+    }
+    retrievePage(_collectionUniqueIdentifier, _pageIdentifier) {
+        throw not_implemented_1.ImbricateNotImplemented.create("RetrievePage", definition_2.IMBRICATE_TRASH_STASH_CAPABILITY_KEY.RETRIEVE_PAGE);
+    }
+    tossScript(_script) {
+        throw not_implemented_1.ImbricateNotImplemented.create("TossScript", definition_2.IMBRICATE_TRASH_STASH_CAPABILITY_KEY.TOSS_SCRIPT);
+    }
+    retrieveScript(_scriptIdentifier) {
+        throw not_implemented_1.ImbricateNotImplemented.create("RetrieveScript", definition_2.IMBRICATE_TRASH_STASH_CAPABILITY_KEY.RETRIEVE_SCRIPT);
+    }
+}
+exports.ImbricateTrashStashBase = ImbricateTrashStashBase;

package/trash/definition.d.ts

@@ -3,7 +3,7 @@
  * @namespace Trash
  * @description Definition
  */
-import { ImbricateCapability } from "../capability/definition";
+import { ImbricateCapabilityRecord } from "../capability/definition";
 export type ImbricateVacantPage = {
     readonly collectionUniqueIdentifier: string;
     readonly pageIdentifier: string;
@@ -15,11 +15,12 @@ export type ImbricateVacantScript = {
     readonly scriptDigest: string;
     readonly script: string;
 };
-export type ImbricateTrashStashCapability = Record<IMBRICATE_TRASH_STASH_CAPABILITY_KEY, ImbricateCapability>;
+export type ImbricateTrashStashCapability = ImbricateCapabilityRecord<IMBRICATE_TRASH_STASH_CAPABILITY_KEY>;
 export declare enum IMBRICATE_TRASH_STASH_CAPABILITY_KEY {
     TOSS_PAGE = "imbricate.trash-stash.page.toss",
     RETRIEVE_PAGE = "imbricate.trash-stash.page.retrieve",
     TOSS_SCRIPT = "imbricate.trash-stash.script.toss",
     RETRIEVE_SCRIPT = "imbricate.trash-stash.script.retrieve"
 }
+export declare const ImbricateTrashStashCapabilityList: IMBRICATE_TRASH_STASH_CAPABILITY_KEY[];
 export declare const createAllAllowImbricateTrashStashCapability: () => ImbricateTrashStashCapability;

package/trash/definition.js

@@ -5,7 +5,7 @@
  * @description Definition
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createAllAllowImbricateTrashStashCapability = exports.IMBRICATE_TRASH_STASH_CAPABILITY_KEY = void 0;
+exports.createAllAllowImbricateTrashStashCapability = exports.ImbricateTrashStashCapabilityList = exports.IMBRICATE_TRASH_STASH_CAPABILITY_KEY = void 0;
 const definition_1 = require("../capability/definition");
 var IMBRICATE_TRASH_STASH_CAPABILITY_KEY;
 (function (IMBRICATE_TRASH_STASH_CAPABILITY_KEY) {
@@ -14,6 +14,12 @@ var IMBRICATE_TRASH_STASH_CAPABILITY_KEY;
     IMBRICATE_TRASH_STASH_CAPABILITY_KEY["TOSS_SCRIPT"] = "imbricate.trash-stash.script.toss";
     IMBRICATE_TRASH_STASH_CAPABILITY_KEY["RETRIEVE_SCRIPT"] = "imbricate.trash-stash.script.retrieve";
 })(IMBRICATE_TRASH_STASH_CAPABILITY_KEY || (exports.IMBRICATE_TRASH_STASH_CAPABILITY_KEY = IMBRICATE_TRASH_STASH_CAPABILITY_KEY = {}));
+exports.ImbricateTrashStashCapabilityList = [
+    IMBRICATE_TRASH_STASH_CAPABILITY_KEY.TOSS_PAGE,
+    IMBRICATE_TRASH_STASH_CAPABILITY_KEY.RETRIEVE_PAGE,
+    IMBRICATE_TRASH_STASH_CAPABILITY_KEY.TOSS_SCRIPT,
+    IMBRICATE_TRASH_STASH_CAPABILITY_KEY.RETRIEVE_SCRIPT,
+];
 const createAllAllowImbricateTrashStashCapability = () => {
     return {
         [IMBRICATE_TRASH_STASH_CAPABILITY_KEY.TOSS_PAGE]: {