@imbricate/core 2.1.0 → 2.3.1

package/collection/base.d.ts

@@ -29,4 +29,5 @@ export declare abstract class ImbricateCollectionBase implements IImbricateColle
     listDirectories(_directories: string[]): PromiseOr<string[]>;
     searchPages(_keyword: string, _config: ImbricateSearchPageConfig): PromiseOr<ImbricatePageSearchResult[]>;
     queryPages(_query: ImbricatePageQuery, _config: ImbricatePageQueryConfig): PromiseOr<IImbricatePage[]>;
+    listSupportedVariants(): Promise<ImbricatePageVariant[]>;
 }

package/collection/base.js

@@ -50,5 +50,8 @@ class ImbricateCollectionBase {
     queryPages(_query, _config) {
         throw not_implemented_1.ImbricateNotImplemented.create("QueryPages", definition_2.IMBRICATE_COLLECTION_CAPABILITY_KEY.LIST_PAGES);
     }
+    listSupportedVariants() {
+        throw not_implemented_1.ImbricateNotImplemented.create("ListSupportedVariants", definition_2.IMBRICATE_COLLECTION_CAPABILITY_KEY.LIST_SUPPORTED_VARIANTS);
+    }
 }
 exports.ImbricateCollectionBase = ImbricateCollectionBase;

package/collection/definition.d.ts

@@ -11,6 +11,7 @@ export declare enum IMBRICATE_COLLECTION_CAPABILITY_KEY {
     RETITLE_PAGE = "imbricate.collection.page.retitle",
     DELETE_PAGE = "imbricate.collection.page.delete",
     GET_PAGE = "imbricate.collection.page.get",
-    LIST_PAGES = "imbricate.collection.page.list"
+    LIST_PAGES = "imbricate.collection.page.list",
+    LIST_SUPPORTED_VARIANTS = "imbricate.collection.page.list-supported-variants"
 }
 export declare const ImbricateCollectionCapabilityList: IMBRICATE_COLLECTION_CAPABILITY_KEY[];

package/collection/definition.js

@@ -14,6 +14,7 @@ var IMBRICATE_COLLECTION_CAPABILITY_KEY;
     IMBRICATE_COLLECTION_CAPABILITY_KEY["DELETE_PAGE"] = "imbricate.collection.page.delete";
     IMBRICATE_COLLECTION_CAPABILITY_KEY["GET_PAGE"] = "imbricate.collection.page.get";
     IMBRICATE_COLLECTION_CAPABILITY_KEY["LIST_PAGES"] = "imbricate.collection.page.list";
+    IMBRICATE_COLLECTION_CAPABILITY_KEY["LIST_SUPPORTED_VARIANTS"] = "imbricate.collection.page.list-supported-variants";
 })(IMBRICATE_COLLECTION_CAPABILITY_KEY || (exports.IMBRICATE_COLLECTION_CAPABILITY_KEY = IMBRICATE_COLLECTION_CAPABILITY_KEY = {}));
 exports.ImbricateCollectionCapabilityList = [
     IMBRICATE_COLLECTION_CAPABILITY_KEY.CREATE_PAGE,
@@ -22,4 +23,5 @@ exports.ImbricateCollectionCapabilityList = [
     IMBRICATE_COLLECTION_CAPABILITY_KEY.DELETE_PAGE,
     IMBRICATE_COLLECTION_CAPABILITY_KEY.GET_PAGE,
     IMBRICATE_COLLECTION_CAPABILITY_KEY.LIST_PAGES,
+    IMBRICATE_COLLECTION_CAPABILITY_KEY.LIST_SUPPORTED_VARIANTS,
 ];

package/collection/interface.d.ts

@@ -24,4 +24,5 @@ export interface IImbricateCollection {
     listDirectories(directories: string[]): PromiseOr<string[]>;
     searchPages(keyword: string, config: ImbricateSearchPageConfig): PromiseOr<ImbricatePageSearchResult[]>;
     queryPages(query: ImbricatePageQuery, config: ImbricatePageQueryConfig): PromiseOr<IImbricatePage[]>;
+    listSupportedVariants(): PromiseOr<ImbricatePageVariant[]>;
 }

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.1",
   "description": "Imbricate Core, Notebook for Engineers",
   "repository": {
     "type": "git",

package/script-manager/base.d.ts

@@ -26,4 +26,5 @@ export declare abstract class ImbricateScriptManagerBase implements IImbricateSc
     listScripts(): PromiseOr<ImbricateScriptSnapshot[]>;
     searchScripts(_keyword: string, _config: ImbricateSearchScriptConfig): PromiseOr<ImbricateScriptSearchResult[]>;
     queryScripts(_query: ImbricateScriptQuery, _config: ImbricateScriptQueryConfig): PromiseOr<IImbricateScript[]>;
+    listSupportedVariants(): Promise<ImbricateScriptVariant[]>;
 }

package/script-manager/base.js

@@ -47,5 +47,8 @@ class ImbricateScriptManagerBase {
     queryScripts(_query, _config) {
         throw not_implemented_1.ImbricateNotImplemented.create("QueryScripts", definition_2.IMBRICATE_SCRIPT_MANAGER_CAPABILITY_KEY.LIST_SCRIPTS);
     }
+    listSupportedVariants() {
+        throw not_implemented_1.ImbricateNotImplemented.create("ListSupportedVariants", definition_2.IMBRICATE_SCRIPT_MANAGER_CAPABILITY_KEY.LIST_SUPPORTED_VARIANTS);
+    }
 }
 exports.ImbricateScriptManagerBase = ImbricateScriptManagerBase;

package/script-manager/definition.d.ts

@@ -12,6 +12,7 @@ export declare enum IMBRICATE_SCRIPT_MANAGER_CAPABILITY_KEY {
     DELETE_SCRIPT = "imbricate.script-manager.delete",
     GET_SCRIPT = "imbricate.script-manager.get",
     LIST_SCRIPTS = "imbricate.script-manager.list",
-    EXECUTE_SCRIPT_SNIPPET = "imbricate.script-manager.execute-script-snippet"
+    EXECUTE_SCRIPT_SNIPPET = "imbricate.script-manager.execute-script-snippet",
+    LIST_SUPPORTED_VARIANTS = "imbricate.script-manager.list-supported-variants"
 }
 export declare const ImbricateScriptManagerCapabilityList: IMBRICATE_SCRIPT_MANAGER_CAPABILITY_KEY[];

package/script-manager/definition.js

@@ -15,6 +15,7 @@ var IMBRICATE_SCRIPT_MANAGER_CAPABILITY_KEY;
     IMBRICATE_SCRIPT_MANAGER_CAPABILITY_KEY["GET_SCRIPT"] = "imbricate.script-manager.get";
     IMBRICATE_SCRIPT_MANAGER_CAPABILITY_KEY["LIST_SCRIPTS"] = "imbricate.script-manager.list";
     IMBRICATE_SCRIPT_MANAGER_CAPABILITY_KEY["EXECUTE_SCRIPT_SNIPPET"] = "imbricate.script-manager.execute-script-snippet";
+    IMBRICATE_SCRIPT_MANAGER_CAPABILITY_KEY["LIST_SUPPORTED_VARIANTS"] = "imbricate.script-manager.list-supported-variants";
 })(IMBRICATE_SCRIPT_MANAGER_CAPABILITY_KEY || (exports.IMBRICATE_SCRIPT_MANAGER_CAPABILITY_KEY = IMBRICATE_SCRIPT_MANAGER_CAPABILITY_KEY = {}));
 exports.ImbricateScriptManagerCapabilityList = [
     IMBRICATE_SCRIPT_MANAGER_CAPABILITY_KEY.CREATE_SCRIPT,
@@ -24,4 +25,5 @@ exports.ImbricateScriptManagerCapabilityList = [
     IMBRICATE_SCRIPT_MANAGER_CAPABILITY_KEY.GET_SCRIPT,
     IMBRICATE_SCRIPT_MANAGER_CAPABILITY_KEY.LIST_SCRIPTS,
     IMBRICATE_SCRIPT_MANAGER_CAPABILITY_KEY.EXECUTE_SCRIPT_SNIPPET,
+    IMBRICATE_SCRIPT_MANAGER_CAPABILITY_KEY.LIST_SUPPORTED_VARIANTS,
 ];

package/script-manager/interface.d.ts

@@ -40,4 +40,5 @@ export interface IImbricateScriptManager {
     listScripts(): PromiseOr<ImbricateScriptSnapshot[]>;
     searchScripts(keyword: string, config: ImbricateSearchScriptConfig): PromiseOr<ImbricateScriptSearchResult[]>;
     queryScripts(query: ImbricateScriptQuery, config: ImbricateScriptQueryConfig): PromiseOr<IImbricateScript[]>;
+    listSupportedVariants(): PromiseOr<ImbricateScriptVariant[]>;
 }

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);
 };