@imbricate/core 2.1.0 → 2.3.0

package/collection-manager/base.d.ts

@@ -7,6 +7,7 @@ import { ImbricateCapabilityBuilder } from "../capability/builder";
 import { ImbricateCapability } from "../capability/definition";
 import { IImbricateCollection } from "../collection/interface";
 import type { PromiseOr } from "../definition/promise";
+import { ImbricatePageVariant } from "../page-variant/definition";
 import { IMBRICATE_COLLECTION_MANAGER_CAPABILITY_KEY, ImbricateCollectionManagerCapability } from "./definition";
 import { IImbricateCollectionManager } from "./interface";
 export declare abstract class ImbricateCollectionManagerBase implements IImbricateCollectionManager {
@@ -14,6 +15,7 @@ export declare abstract class ImbricateCollectionManagerBase implements IImbrica
     static allAllowCapability(): ImbricateCollectionManagerCapability;
     static allDenyCapability(): ImbricateCollectionManagerCapability;
     abstract readonly capabilities: ImbricateCollectionManagerCapability;
+    findSupportedVariants(_variant?: Partial<ImbricatePageVariant>): Promise<ImbricatePageVariant[]>;
     createCollection(_collectionName: string, _description?: string): PromiseOr<IImbricateCollection>;
     renameCollection(_collectionUniqueIdentifier: string, _newCollectionName: string): PromiseOr<void>;
     deleteCollection(_collectionUniqueIdentifier: string): PromiseOr<void>;

package/collection-manager/base.js

@@ -4,6 +4,15 @@
  * @namespace CollectionManager
  * @description Base
  */
+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.ImbricateCollectionManagerBase = void 0;
 const builder_1 = require("../capability/builder");
@@ -20,6 +29,11 @@ class ImbricateCollectionManagerBase {
     static allDenyCapability() {
         return this.buildCapability((0, definition_1.createDenyImbricateCapability)()).build();
     }
+    findSupportedVariants(_variant) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [];
+        });
+    }
     createCollection(_collectionName, _description) {
         throw not_implemented_1.ImbricateNotImplemented.create("CreateCollection", definition_2.IMBRICATE_COLLECTION_MANAGER_CAPABILITY_KEY.CREATE_COLLECTION);
     }

package/collection-manager/interface.d.ts

@@ -5,12 +5,21 @@
  */
 import { IImbricateCollection } from "../collection/interface";
 import { PromiseOr } from "../definition/promise";
+import { ImbricatePageVariant } from "../page-variant/definition";
 import { ImbricateCollectionManagerCapability } from "./definition";
 export interface IImbricateCollectionManager {
     /**
      * Capabilities of the collection manager
      */
     readonly capabilities: ImbricateCollectionManagerCapability;
+    /**
+     * Find supported variants
+     *
+     * @param variant the partial variant to find, if not provided, find all
+     *
+     * @returns supported variants
+     */
+    findSupportedVariants(variant?: Partial<ImbricatePageVariant>): PromiseOr<ImbricatePageVariant[]>;
     /**
      * Create a collection
      *

package/executable-manager/base.d.ts

@@ -15,6 +15,7 @@ export declare abstract class ImbricateExecutableManagerBase implements IImbrica
     static allAllowCapability(): ImbricateExecutableManagerCapability;
     static allDenyCapability(): ImbricateExecutableManagerCapability;
     abstract readonly capabilities: ImbricateExecutableManagerCapability;
+    findSupportedVariants(_variant?: Partial<ImbricateScriptVariant>): Promise<ImbricateScriptVariant[]>;
     executeScript(_script: IImbricateScript, _parameters: ImbricateExecuteParameters, _environment: ImbricateExecuteEnvironment): Promise<ImbricateExecuteResult>;
     executeSnippet(_snippet: string, _variant: ImbricateScriptVariant, _parameters: ImbricateExecuteParameters, _environment: ImbricateExecuteEnvironment): Promise<ImbricateExecuteResult>;
 }

package/executable-manager/base.js

@@ -4,6 +4,15 @@
  * @namespace ExecutableManager
  * @description Base
  */
+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.ImbricateExecutableManagerBase = void 0;
 const builder_1 = require("../capability/builder");
@@ -20,6 +29,11 @@ class ImbricateExecutableManagerBase {
     static allDenyCapability() {
         return this.buildCapability((0, definition_1.createDenyImbricateCapability)()).build();
     }
+    findSupportedVariants(_variant) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [];
+        });
+    }
     executeScript(_script, _parameters, _environment) {
         throw not_implemented_1.ImbricateNotImplemented.create("ExecuteScript", definition_2.IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY.EXECUTE_SCRIPT);
     }

package/executable-manager/interface.d.ts

@@ -13,6 +13,14 @@ export interface IImbricateExecutableManager {
      * Capabilities of the executable manager
      */
     readonly capabilities: ImbricateExecutableManagerCapability;
+    /**
+     * Find supported variants
+     *
+     * @param variant the partial variant to find, if not provided, find all
+     *
+     * @returns supported variants
+     */
+    findSupportedVariants(variant?: Partial<ImbricateScriptVariant>): PromiseOr<ImbricateScriptVariant[]>;
     /**
      * Execute a script
      *

package/package.json

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

package/script-variant/definition.d.ts

@@ -8,10 +8,15 @@ export declare enum IMBRICATE_SCRIPT_LANGUAGE {
     TYPESCRIPT = "typescript"
 }
 export declare const IMBRICATE_SCRIPT_LANGUAGE_LIST: IMBRICATE_SCRIPT_LANGUAGE[];
+export declare enum IMBRICATE_SCRIPT_EXECUTE_LAYER {
+    ORIGIN = "ORIGIN",
+    INTERFACE = "INTERFACE"
+}
 export declare const isValidImbricateScriptLanguage: (language: unknown) => language is IMBRICATE_SCRIPT_LANGUAGE;
 export type ImbricateScriptVariant = {
     readonly language: IMBRICATE_SCRIPT_LANGUAGE;
     readonly engine: string;
     readonly version: string;
+    readonly layer: IMBRICATE_SCRIPT_EXECUTE_LAYER;
 };
 export declare const isImbricateScriptVariant: (variant: unknown) => variant is ImbricateScriptVariant;

package/script-variant/definition.js

@@ -5,7 +5,7 @@
  * @description Definition
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isImbricateScriptVariant = exports.isValidImbricateScriptLanguage = exports.IMBRICATE_SCRIPT_LANGUAGE_LIST = exports.IMBRICATE_SCRIPT_LANGUAGE = void 0;
+exports.isImbricateScriptVariant = exports.isValidImbricateScriptLanguage = exports.IMBRICATE_SCRIPT_EXECUTE_LAYER = exports.IMBRICATE_SCRIPT_LANGUAGE_LIST = exports.IMBRICATE_SCRIPT_LANGUAGE = void 0;
 var IMBRICATE_SCRIPT_LANGUAGE;
 (function (IMBRICATE_SCRIPT_LANGUAGE) {
     IMBRICATE_SCRIPT_LANGUAGE["JAVASCRIPT"] = "javascript";
@@ -15,6 +15,11 @@ exports.IMBRICATE_SCRIPT_LANGUAGE_LIST = [
     IMBRICATE_SCRIPT_LANGUAGE.JAVASCRIPT,
     IMBRICATE_SCRIPT_LANGUAGE.TYPESCRIPT,
 ];
+var IMBRICATE_SCRIPT_EXECUTE_LAYER;
+(function (IMBRICATE_SCRIPT_EXECUTE_LAYER) {
+    IMBRICATE_SCRIPT_EXECUTE_LAYER["ORIGIN"] = "ORIGIN";
+    IMBRICATE_SCRIPT_EXECUTE_LAYER["INTERFACE"] = "INTERFACE";
+})(IMBRICATE_SCRIPT_EXECUTE_LAYER || (exports.IMBRICATE_SCRIPT_EXECUTE_LAYER = IMBRICATE_SCRIPT_EXECUTE_LAYER = {}));
 const isValidImbricateScriptLanguage = (language) => {
     return exports.IMBRICATE_SCRIPT_LANGUAGE_LIST.includes(language);
 };