@imbricate/core 1.24.2 → 1.24.4

package/binary-storage/base.d.ts

@@ -8,7 +8,7 @@ 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 {
+export declare abstract class ImbricateBinaryStorageBase implements IImbricateBinaryStorage {
     static buildCapability(initial?: ImbricateCapability): ImbricateCapabilityBuilder<IMBRICATE_BINARY_STORAGE_CAPABILITY_KEY>;
     static allAllowCapability(): ImbricateBinaryStorageCapability;
     static allDenyCapability(): ImbricateBinaryStorageCapability;

package/binary-storage/base.js

@@ -5,12 +5,12 @@
  * @description Base
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImbricateBaseBinaryStorage = void 0;
+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 ImbricateBaseBinaryStorage {
+class ImbricateBinaryStorageBase {
     static buildCapability(initial = (0, definition_1.createDenyImbricateCapability)()) {
         return builder_1.ImbricateCapabilityBuilder.create(definition_2.ImbricateBinaryStorageCapabilityList, initial);
     }
@@ -27,4 +27,4 @@ class ImbricateBaseBinaryStorage {
         throw not_implemented_1.ImbricateNotImplemented.create("ValidateBinaryBase64", definition_2.IMBRICATE_BINARY_STORAGE_CAPABILITY_KEY.UPLOAD_FILE);
     }
 }
-exports.ImbricateBaseBinaryStorage = ImbricateBaseBinaryStorage;
+exports.ImbricateBinaryStorageBase = ImbricateBinaryStorageBase;

package/capability/builder.d.ts

@@ -3,10 +3,13 @@
  * @namespace Capability
  * @description Builder
  */
-import type { ImbricateCapability, ImbricateCapabilityKey, ImbricateCapabilityRecord } from "./definition";
+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

@@ -7,6 +7,7 @@
 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);
@@ -15,6 +16,18 @@ class ImbricateCapabilityBuilder {
     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).map((key) => {
             return {

package/function/base.d.ts

@@ -5,6 +5,7 @@
  */
 import { ImbricateCapabilityBuilder } from "../capability/builder";
 import { ImbricateCapability } from "../capability/definition";
+import type { PromiseOr } from "../definition/promise";
 import type { IImbricateOrigin } from "../origin/interface";
 import { IMBRICATE_FUNCTION_CAPABILITY_KEY, ImbricateFunction, ImbricateFunctionCapability } from "./definition";
 import type { IImbricateFunctionManager } from "./interface";
@@ -14,5 +15,5 @@ export declare abstract class ImbricateFunctionManagerBase implements IImbricate
     static allDenyCapability(): ImbricateFunctionCapability;
     abstract readonly capabilities: ImbricateFunctionCapability;
     findSynchronousOriginFunctions(): Array<ImbricateFunction<IImbricateOrigin>>;
-    findAllOriginFunctions(): Array<ImbricateFunction<IImbricateOrigin>>;
+    findAllOriginFunctions(): PromiseOr<Array<ImbricateFunction<IImbricateOrigin>>>;
 }

package/function/interface.d.ts

@@ -11,6 +11,16 @@ export interface IImbricateFunctionManager {
      * Capabilities of the function manager
      */
     readonly capabilities: ImbricateFunctionCapability;
+    /**
+     * Find all synchronous origin functions
+     *
+     * @returns an array of synchronous origin functions
+     */
     findSynchronousOriginFunctions(): Array<ImbricateFunction<IImbricateOrigin>>;
+    /**
+     * Find all origin functions, including asynchronous functions and synchronous functions
+     *
+     * @returns a promise of an array of origin functions
+     */
     findAllOriginFunctions(): PromiseOr<Array<ImbricateFunction<IImbricateOrigin>>>;
 }

package/package.json

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