@imbricate/core 1.20.0 → 1.21.0

package/binary-storage/interface.d.ts

@@ -4,7 +4,12 @@
  * @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
      *

package/function/definition.d.ts

@@ -3,6 +3,7 @@
  * @namespace Function
  * @description Definition
  */
+import { ImbricateCapability } from "../capability/definition";
 import { PromiseOr } from "../definition/promise";
 export type ImbricateFunction<Target> = {
     readonly title: string;
@@ -10,3 +11,8 @@ export type ImbricateFunction<Target> = {
     readonly execute: ImbricateFunctionExecute<Target>;
 };
 export type ImbricateFunctionExecute<Target> = (target: Target) => PromiseOr<void>;
+export type ImbricateFunctionCapability = Record<IMBRICATE_FUNCTION_CAPABILITY_KEY, ImbricateCapability>;
+export declare enum IMBRICATE_FUNCTION_CAPABILITY_KEY {
+    FIND_ORIGIN_FUNCTIONS = "imbricate.function.origin.find"
+}
+export declare const createAllAllowImbricateFunctionCapability: () => ImbricateFunctionCapability;

package/function/definition.js

@@ -5,3 +5,17 @@
  * @description Definition
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAllAllowImbricateFunctionCapability = 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 = {}));
+const createAllAllowImbricateFunctionCapability = () => {
+    return {
+        [IMBRICATE_FUNCTION_CAPABILITY_KEY.FIND_ORIGIN_FUNCTIONS]: {
+            effect: definition_1.IMBRICATE_CAPABILITY_EFFECT.ALLOW,
+        },
+    };
+};
+exports.createAllAllowImbricateFunctionCapability = createAllAllowImbricateFunctionCapability;

package/function/interface.d.ts

@@ -5,8 +5,12 @@
  */
 import { PromiseOr } from "../definition/promise";
 import { IImbricateOrigin } from "../origin/interface";
-import { ImbricateFunction } from "./definition";
+import { ImbricateFunction, ImbricateFunctionCapability } from "./definition";
 export interface IImbricateFunctionManager {
+    /**
+     * Capabilities of the function manager
+     */
+    readonly capabilities: ImbricateFunctionCapability;
     findSynchronousOriginFunctions(): Array<ImbricateFunction<IImbricateOrigin>>;
     findAllOriginFunctions(): PromiseOr<Array<ImbricateFunction<IImbricateOrigin>>>;
 }

package/index.d.ts

@@ -32,3 +32,5 @@ export * from "./script/definition";
 export * from "./script/interface";
 export * from "./search/prefix";
 export * from "./search/snippet";
+export * from "./trash/definition";
+export * from "./trash/interface";

package/index.js

@@ -48,3 +48,5 @@ __exportStar(require("./script/definition"), exports);
 __exportStar(require("./script/interface"), exports);
 __exportStar(require("./search/prefix"), exports);
 __exportStar(require("./search/snippet"), exports);
+__exportStar(require("./trash/definition"), exports);
+__exportStar(require("./trash/interface"), exports);

package/origin/definition.d.ts

@@ -14,6 +14,9 @@ export type ImbricateOriginMetadata = {
 };
 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",
     CREATE_COLLECTION = "imbricate.origin.collection.create",
     RENAME_COLLECTION = "imbricate.origin.collection.rename",
     DELETE_COLLECTION = "imbricate.origin.collection.delete",

package/origin/definition.js

@@ -15,6 +15,9 @@ var IMBRICATE_DIGEST_ALGORITHM;
 })(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["CREATE_COLLECTION"] = "imbricate.origin.collection.create";
     IMBRICATE_ORIGIN_CAPABILITY_KEY["RENAME_COLLECTION"] = "imbricate.origin.collection.rename";
     IMBRICATE_ORIGIN_CAPABILITY_KEY["DELETE_COLLECTION"] = "imbricate.origin.collection.delete";
@@ -29,6 +32,15 @@ var IMBRICATE_ORIGIN_CAPABILITY_KEY;
 })(IMBRICATE_ORIGIN_CAPABILITY_KEY || (exports.IMBRICATE_ORIGIN_CAPABILITY_KEY = IMBRICATE_ORIGIN_CAPABILITY_KEY = {}));
 const createAllAllowImbricateOriginCapability = () => {
     return {
+        [IMBRICATE_ORIGIN_CAPABILITY_KEY.ORIGIN_FUNCTION]: {
+            effect: definition_1.IMBRICATE_CAPABILITY_EFFECT.ALLOW,
+        },
+        [IMBRICATE_ORIGIN_CAPABILITY_KEY.ORIGIN_BINARY_STORAGE]: {
+            effect: definition_1.IMBRICATE_CAPABILITY_EFFECT.ALLOW,
+        },
+        [IMBRICATE_ORIGIN_CAPABILITY_KEY.ORIGIN_TRASH_STASH]: {
+            effect: definition_1.IMBRICATE_CAPABILITY_EFFECT.ALLOW,
+        },
         [IMBRICATE_ORIGIN_CAPABILITY_KEY.CREATE_COLLECTION]: {
             effect: definition_1.IMBRICATE_CAPABILITY_EFFECT.ALLOW,
         },

package/origin/interface.d.ts

@@ -12,26 +12,62 @@ import { ImbricateScriptMetadata, ImbricateScriptSearchResult, ImbricateScriptSn
 import { IImbricateScript } from "../script/interface";
 import { ImbricateOriginCapability, ImbricateOriginMetadata } 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
+     */
     getFunctionManger(): IImbricateFunctionManager;
+    /**
+     * Get binary storage
+     *
+     * @returns Binary storage
+     */
     getBinaryStorage(): IImbricateBinaryStorage;
     /**
      * Create a collection
      *
      * @param collectionName Collection name
      * @param description Collection description
+     *
+     * @returns Created collection
      */
-    createCollection(collectionName: string, description?: string): PromiseOr<void>;
+    createCollection(collectionName: string, description?: string): PromiseOr<IImbricateOriginCollection>;
     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[]>;
+    /**
+     * Create a script
+     *
+     * @param scriptName Script name
+     * @param initialScript Initial script content
+     * @param description Script description
+     *
+     * @returns Created script
+     */
     createScript(scriptName: string, initialScript: string, description?: string): PromiseOr<IImbricateScript>;
     putScript(scriptMetadata: ImbricateScriptMetadata, script: string): PromiseOr<IImbricateScript>;
     renameScript(identifier: string, newScriptName: string): PromiseOr<void>;

package/package.json

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

package/trash/definition.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @author WMXPY
+ * @namespace Trash
+ * @description Definition
+ */
+import { ImbricateCapability } from "../capability/definition";
+export type ImbricateVacantPage = {
+    readonly collectionUniqueIdentifier: string;
+    readonly pageIdentifier: string;
+    readonly contentDigest: string;
+    readonly content: string;
+};
+export type ImbricateVacantScript = {
+    readonly scriptIdentifier: string;
+    readonly scriptDigest: string;
+    readonly script: string;
+};
+export type ImbricateTrashStashCapability = Record<IMBRICATE_TRASH_STASH_CAPABILITY_KEY, ImbricateCapability>;
+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 createAllAllowImbricateTrashStashCapability: () => ImbricateTrashStashCapability;

package/trash/definition.js

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Trash
+ * @description Definition
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAllAllowImbricateTrashStashCapability = 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) {
+    IMBRICATE_TRASH_STASH_CAPABILITY_KEY["TOSS_PAGE"] = "imbricate.trash-stash.page.toss";
+    IMBRICATE_TRASH_STASH_CAPABILITY_KEY["RETRIEVE_PAGE"] = "imbricate.trash-stash.page.retrieve";
+    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 = {}));
+const createAllAllowImbricateTrashStashCapability = () => {
+    return {
+        [IMBRICATE_TRASH_STASH_CAPABILITY_KEY.TOSS_PAGE]: {
+            effect: definition_1.IMBRICATE_CAPABILITY_EFFECT.ALLOW,
+        },
+        [IMBRICATE_TRASH_STASH_CAPABILITY_KEY.RETRIEVE_PAGE]: {
+            effect: definition_1.IMBRICATE_CAPABILITY_EFFECT.ALLOW,
+        },
+        [IMBRICATE_TRASH_STASH_CAPABILITY_KEY.TOSS_SCRIPT]: {
+            effect: definition_1.IMBRICATE_CAPABILITY_EFFECT.ALLOW,
+        },
+        [IMBRICATE_TRASH_STASH_CAPABILITY_KEY.RETRIEVE_SCRIPT]: {
+            effect: definition_1.IMBRICATE_CAPABILITY_EFFECT.ALLOW,
+        },
+    };
+};
+exports.createAllAllowImbricateTrashStashCapability = createAllAllowImbricateTrashStashCapability;

package/trash/interface.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @author WMXPY
+ * @namespace Trash
+ * @description Interface
+ */
+import { PromiseOr } from "../definition/promise";
+import { ImbricateTrashStashCapability, ImbricateVacantPage, ImbricateVacantScript } from "./definition";
+export interface IImbricateTrashStash {
+    /**
+     * Capabilities of the trash stash
+     */
+    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/interface.js

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