@imbricate/core 1.34.2 → 2.0.0

package/collection/base.d.ts

@@ -6,7 +6,8 @@
 import { ImbricateCapabilityBuilder } from "../capability/builder";
 import { ImbricateCapability } from "../capability/definition";
 import type { PromiseOr } from "../definition/promise";
-import type { IMBRICATE_PAGE_VARIANT, ImbricatePageMetadata, ImbricatePageSearchResult, ImbricatePageSnapshot } from "../page/definition";
+import { ImbricatePageVariant } from "../page-variant/definition";
+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";
@@ -18,7 +19,7 @@ export declare abstract class ImbricateCollectionBase implements IImbricateColle
     abstract readonly collectionName: string;
     abstract readonly uniqueIdentifier: string;
     abstract readonly capabilities: ImbricateCollectionCapability;
-    createPage(_directories: string[], _title: string, _variant: IMBRICATE_PAGE_VARIANT, _initialContent: string, _description?: string): PromiseOr<IImbricatePage>;
+    createPage(_directories: string[], _title: string, _variant: ImbricatePageVariant, _initialContent: string, _description?: string): PromiseOr<IImbricatePage>;
     putPage(_pageMetadata: ImbricatePageMetadata, _content: string): PromiseOr<IImbricatePage>;
     retitlePage(_identifier: string, _newTitle: string): PromiseOr<void>;
     deletePage(_identifier: string): PromiseOr<void>;

package/collection/interface.d.ts

@@ -4,7 +4,8 @@
  * @description Interface
  */
 import type { PromiseOr } from "../definition/promise";
-import type { IMBRICATE_PAGE_VARIANT, ImbricatePageMetadata, ImbricatePageSearchResult, ImbricatePageSnapshot } from "../page/definition";
+import { ImbricatePageVariant } from "../page-variant/definition";
+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";
@@ -13,7 +14,7 @@ export interface IImbricateCollection {
     readonly uniqueIdentifier: string;
     readonly description?: string;
     readonly capabilities: ImbricateCollectionCapability;
-    createPage(directories: string[], title: string, variant: IMBRICATE_PAGE_VARIANT, initialContent: string, description?: string): PromiseOr<IImbricatePage>;
+    createPage(directories: string[], title: string, variant: ImbricatePageVariant, initialContent: string, description?: string): PromiseOr<IImbricatePage>;
     putPage(pageMetadata: ImbricatePageMetadata, content: string): PromiseOr<IImbricatePage>;
     retitlePage(identifier: string, newTitle: string): PromiseOr<void>;
     deletePage(identifier: string): PromiseOr<void>;

package/executable-manager/base.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @author WMXPY
+ * @namespace ExecutableManager
+ * @description Base
+ */
+import { ImbricateCapabilityBuilder } from "../capability/builder";
+import { ImbricateCapability } from "../capability/definition";
+import { ImbricateExecuteEnvironment, ImbricateExecuteParameters, ImbricateExecuteResult } from "../execute/definition";
+import { ImbricateScriptVariant } from "../script-variant/definition";
+import { IImbricateScript } from "../script/interface";
+import { IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY, ImbricateExecutableManagerCapability } from "./definition";
+import { IImbricateExecutableManager } from "./interface";
+export declare abstract class ImbricateExecutableManagerBase implements IImbricateExecutableManager {
+    static buildCapability(initial?: ImbricateCapability): ImbricateCapabilityBuilder<IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY>;
+    static allAllowCapability(): ImbricateExecutableManagerCapability;
+    static allDenyCapability(): ImbricateExecutableManagerCapability;
+    abstract readonly capabilities: ImbricateExecutableManagerCapability;
+    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

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace ExecutableManager
+ * @description Base
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImbricateExecutableManagerBase = 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 ImbricateExecutableManagerBase {
+    static buildCapability(initial = (0, definition_1.createDenyImbricateCapability)()) {
+        return builder_1.ImbricateCapabilityBuilder.create(definition_2.ImbricateExecutableManagerCapabilityList, initial);
+    }
+    static allAllowCapability() {
+        return this.buildCapability((0, definition_1.createAllowImbricateCapability)()).build();
+    }
+    static allDenyCapability() {
+        return this.buildCapability((0, definition_1.createDenyImbricateCapability)()).build();
+    }
+    executeScript(_script, _parameters, _environment) {
+        throw not_implemented_1.ImbricateNotImplemented.create("ExecuteScript", definition_2.IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY.EXECUTE_SCRIPT);
+    }
+    executeSnippet(_snippet, _variant, _parameters, _environment) {
+        throw not_implemented_1.ImbricateNotImplemented.create("ExecuteSnippet", definition_2.IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY.EXECUTE_SNIPPET);
+    }
+}
+exports.ImbricateExecutableManagerBase = ImbricateExecutableManagerBase;

package/executable-manager/definition.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @author WMXPY
+ * @namespace ExecutableManager
+ * @description Definition
+ */
+import { ImbricateCapability } from "../capability/definition";
+export type ImbricateExecutableManagerCapability = Record<IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY, ImbricateCapability>;
+export declare enum IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY {
+    EXECUTE_SCRIPT = "imbricate.executable-manager.execute-script",
+    EXECUTE_SNIPPET = "imbricate.executable-manager.execute-snippet"
+}
+export declare const ImbricateExecutableManagerCapabilityList: IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY[];

package/executable-manager/definition.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace ExecutableManager
+ * @description Definition
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImbricateExecutableManagerCapabilityList = exports.IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY = void 0;
+var IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY;
+(function (IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY) {
+    IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY["EXECUTE_SCRIPT"] = "imbricate.executable-manager.execute-script";
+    IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY["EXECUTE_SNIPPET"] = "imbricate.executable-manager.execute-snippet";
+})(IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY || (exports.IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY = IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY = {}));
+exports.ImbricateExecutableManagerCapabilityList = [
+    IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY.EXECUTE_SCRIPT,
+    IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY.EXECUTE_SNIPPET,
+];

package/executable-manager/interface.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @author WMXPY
+ * @namespace ExecutableManager
+ * @description Interface
+ */
+import { PromiseOr } from "../definition/promise";
+import { ImbricateExecuteEnvironment, ImbricateExecuteParameters, ImbricateExecuteResult } from "../execute/definition";
+import { ImbricateScriptVariant } from "../script-variant/definition";
+import { IImbricateScript } from "../script/interface";
+import { ImbricateExecutableManagerCapability } from "./definition";
+export interface IImbricateExecutableManager {
+    /**
+     * Capabilities of the executable manager
+     */
+    readonly capabilities: ImbricateExecutableManagerCapability;
+    /**
+     * Execute a script
+     *
+     * @param script
+     * @param parameters
+     * @param environment
+     *
+     * @returns result of the execution
+     */
+    executeScript(script: IImbricateScript, parameters: ImbricateExecuteParameters, environment: ImbricateExecuteEnvironment): PromiseOr<ImbricateExecuteResult>;
+    /**
+     * Execute a snippet
+     *
+     * @param snippet
+     * @param parameters
+     * @param environment
+     *
+     * @returns result of the execution
+     */
+    executeSnippet(snippet: string, variant: ImbricateScriptVariant, parameters: ImbricateExecuteParameters, environment: ImbricateExecuteEnvironment): PromiseOr<ImbricateExecuteResult>;
+}

package/executable-manager/interface.js

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

package/execute/definition.d.ts

@@ -3,12 +3,6 @@
  * @namespace Execute
  * @description Definition
  */
-export declare enum IMBRICATE_EXECUTABLE_VARIANT {
-    JAVASCRIPT_NODE = "javascript-node",
-    TYPESCRIPT_NODE = "typescript-node"
-}
-export declare const IMBRICATE_SCRIPT_VARIANT_LIST: IMBRICATE_EXECUTABLE_VARIANT[];
-export declare const isValidImbricateExecutableVariant: (variant: unknown) => variant is IMBRICATE_EXECUTABLE_VARIANT;
 export declare enum IMBRICATE_EXECUTE_RESULT_CODE {
     NOT_SUPPORT = "NOT_SUPPORT",
     SUCCESS = "SUCCESS",

package/execute/definition.js

@@ -5,20 +5,7 @@
  * @description Definition
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IMBRICATE_EXECUTE_RESULT_CODE = exports.isValidImbricateExecutableVariant = exports.IMBRICATE_SCRIPT_VARIANT_LIST = exports.IMBRICATE_EXECUTABLE_VARIANT = void 0;
-var IMBRICATE_EXECUTABLE_VARIANT;
-(function (IMBRICATE_EXECUTABLE_VARIANT) {
-    IMBRICATE_EXECUTABLE_VARIANT["JAVASCRIPT_NODE"] = "javascript-node";
-    IMBRICATE_EXECUTABLE_VARIANT["TYPESCRIPT_NODE"] = "typescript-node";
-})(IMBRICATE_EXECUTABLE_VARIANT || (exports.IMBRICATE_EXECUTABLE_VARIANT = IMBRICATE_EXECUTABLE_VARIANT = {}));
-exports.IMBRICATE_SCRIPT_VARIANT_LIST = [
-    IMBRICATE_EXECUTABLE_VARIANT.JAVASCRIPT_NODE,
-    IMBRICATE_EXECUTABLE_VARIANT.TYPESCRIPT_NODE,
-];
-const isValidImbricateExecutableVariant = (variant) => {
-    return exports.IMBRICATE_SCRIPT_VARIANT_LIST.includes(variant);
-};
-exports.isValidImbricateExecutableVariant = isValidImbricateExecutableVariant;
+exports.IMBRICATE_EXECUTE_RESULT_CODE = void 0;
 var IMBRICATE_EXECUTE_RESULT_CODE;
 (function (IMBRICATE_EXECUTE_RESULT_CODE) {
     IMBRICATE_EXECUTE_RESULT_CODE["NOT_SUPPORT"] = "NOT_SUPPORT";

package/index.d.ts

@@ -20,14 +20,17 @@ export * from "./definition/listable";
 export * from "./definition/promise";
 export * from "./error/imbricate-error";
 export * from "./error/not-implemented";
+export * from "./executable-manager/base";
+export * from "./executable-manager/definition";
+export * from "./executable-manager/interface";
 export * from "./execute/definition";
-export * from "./execute/extension";
 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-variant/definition";
 export * from "./page/base";
 export * from "./page/definition";
 export * from "./page/interface";
@@ -37,6 +40,8 @@ export * from "./query/script";
 export * from "./script-manager/base";
 export * from "./script-manager/definition";
 export * from "./script-manager/interface";
+export * from "./script-variant/definition";
+export * from "./script-variant/extension";
 export * from "./script/base";
 export * from "./script/definition";
 export * from "./script/interface";

package/index.js

@@ -36,14 +36,17 @@ __exportStar(require("./definition/listable"), exports);
 __exportStar(require("./definition/promise"), exports);
 __exportStar(require("./error/imbricate-error"), exports);
 __exportStar(require("./error/not-implemented"), exports);
+__exportStar(require("./executable-manager/base"), exports);
+__exportStar(require("./executable-manager/definition"), exports);
+__exportStar(require("./executable-manager/interface"), exports);
 __exportStar(require("./execute/definition"), exports);
-__exportStar(require("./execute/extension"), 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-variant/definition"), exports);
 __exportStar(require("./page/base"), exports);
 __exportStar(require("./page/definition"), exports);
 __exportStar(require("./page/interface"), exports);
@@ -53,6 +56,8 @@ __exportStar(require("./query/script"), exports);
 __exportStar(require("./script-manager/base"), exports);
 __exportStar(require("./script-manager/definition"), exports);
 __exportStar(require("./script-manager/interface"), exports);
+__exportStar(require("./script-variant/definition"), exports);
+__exportStar(require("./script-variant/extension"), exports);
 __exportStar(require("./script/base"), exports);
 __exportStar(require("./script/definition"), exports);
 __exportStar(require("./script/interface"), exports);

package/package.json

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

package/page/base.d.ts

@@ -6,7 +6,8 @@
 import { ImbricateCapabilityBuilder } from "../capability/builder";
 import { ImbricateCapability } from "../capability/definition";
 import type { PromiseOr } from "../definition/promise";
-import { IMBRICATE_PAGE_CAPABILITY_KEY, IMBRICATE_PAGE_VARIANT, ImbricatePageCapability, ImbricatePageHistoryRecord } from "./definition";
+import { ImbricatePageVariant } from "../page-variant/definition";
+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>;
@@ -15,7 +16,7 @@ export declare abstract class ImbricatePageBase implements IImbricatePage {
     abstract readonly title: string;
     abstract readonly directories: string[];
     abstract readonly identifier: string;
-    abstract readonly variant: IMBRICATE_PAGE_VARIANT;
+    abstract readonly variant: ImbricatePageVariant;
     abstract readonly digest: string;
     abstract readonly historyRecords: ImbricatePageHistoryRecord[];
     abstract readonly description?: string;

package/page/definition.d.ts

@@ -4,30 +4,26 @@
  * @description Definition
  */
 import { ImbricateCapability } from "../capability/definition";
+import { ImbricatePageVariant } from "../page-variant/definition";
 import { IMBRICATE_SEARCH_RESULT_TYPE, ImbricateSearchResult, ImbricateSearchSnippet } from "../search/snippet";
 export type ImbricatePageAttributes = Record<string, string>;
 export type ImbricatePageSearchResult = ImbricateSearchResult<IMBRICATE_SEARCH_RESULT_TYPE.PAGE>;
 export type ImbricatePageSearchSnippet = ImbricateSearchSnippet<IMBRICATE_SEARCH_RESULT_TYPE.PAGE>;
-export declare enum IMBRICATE_PAGE_VARIANT {
-    PLAIN_TEXT = "plain-text",
-    MARKDOWN = "markdown"
-}
-export declare const IMBRICATE_PAGE_VARIANT_LIST: IMBRICATE_PAGE_VARIANT[];
-export declare const isValidImbricatePageVariant: (variant: unknown) => variant is IMBRICATE_PAGE_VARIANT;
 export type ImbricatePageSnapshot = {
     readonly title: string;
     readonly directories: string[];
     readonly identifier: string;
-    readonly variant: IMBRICATE_PAGE_VARIANT;
+    readonly variant: ImbricatePageVariant;
 };
 export type ImbricatePageHistoryRecord = {
-    readonly updatedAt: Date;
+    readonly author: string;
     readonly digest: string;
+    readonly updatedAt: Date;
 };
 export type ImbricatePageMetadata = {
     readonly createdAt: Date;
-    readonly updatedAt: Date;
     readonly digest: string;
+    readonly updatedAt: Date;
     readonly attributes: ImbricatePageAttributes;
     readonly historyRecords: ImbricatePageHistoryRecord[];
     readonly description?: string;

package/page/definition.js

@@ -5,20 +5,7 @@
  * @description Definition
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImbricatePageCapabilityList = exports.IMBRICATE_PAGE_CAPABILITY_KEY = exports.isValidImbricatePageVariant = exports.IMBRICATE_PAGE_VARIANT_LIST = exports.IMBRICATE_PAGE_VARIANT = void 0;
-var IMBRICATE_PAGE_VARIANT;
-(function (IMBRICATE_PAGE_VARIANT) {
-    IMBRICATE_PAGE_VARIANT["PLAIN_TEXT"] = "plain-text";
-    IMBRICATE_PAGE_VARIANT["MARKDOWN"] = "markdown";
-})(IMBRICATE_PAGE_VARIANT || (exports.IMBRICATE_PAGE_VARIANT = IMBRICATE_PAGE_VARIANT = {}));
-exports.IMBRICATE_PAGE_VARIANT_LIST = [
-    IMBRICATE_PAGE_VARIANT.PLAIN_TEXT,
-    IMBRICATE_PAGE_VARIANT.MARKDOWN,
-];
-const isValidImbricatePageVariant = (variant) => {
-    return exports.IMBRICATE_PAGE_VARIANT_LIST.includes(variant);
-};
-exports.isValidImbricatePageVariant = isValidImbricatePageVariant;
+exports.ImbricatePageCapabilityList = exports.IMBRICATE_PAGE_CAPABILITY_KEY = void 0;
 var IMBRICATE_PAGE_CAPABILITY_KEY;
 (function (IMBRICATE_PAGE_CAPABILITY_KEY) {
     IMBRICATE_PAGE_CAPABILITY_KEY["READ"] = "imbricate.page.read";

package/page/interface.d.ts

@@ -4,12 +4,13 @@
  * @description Interface
  */
 import { PromiseOr } from "../definition/promise";
-import { IMBRICATE_PAGE_VARIANT, ImbricatePageAttributes, ImbricatePageCapability, ImbricatePageHistoryRecord } from "./definition";
+import { ImbricatePageVariant } from "../page-variant/definition";
+import { ImbricatePageAttributes, ImbricatePageCapability, ImbricatePageHistoryRecord } from "./definition";
 export interface IImbricatePage {
     readonly title: string;
     readonly directories: string[];
     readonly identifier: string;
-    readonly variant: IMBRICATE_PAGE_VARIANT;
+    readonly variant: ImbricatePageVariant;
     readonly digest: string;
     readonly historyRecords: ImbricatePageHistoryRecord[];
     readonly description?: string;
@@ -20,8 +21,33 @@ export interface IImbricatePage {
     writeContent(content: string): PromiseOr<void>;
     readAttributes(): PromiseOr<ImbricatePageAttributes>;
     writeAttribute(key: string, value: string): PromiseOr<void>;
+    /**
+     * Refresh Updated At and Digest, and add a history record
+     * Recommended to use this method when updating the page
+     *
+     * @param updatedAt Updated At
+     * @param digest Content Digest
+     */
     refreshUpdateMetadata(updatedAt: Date, digest: string): PromiseOr<void>;
+    /**
+     * Refresh Updated At
+     * Prefer `refreshUpdateMetadata` in most cases
+     *
+     * @param updatedAt Updated At
+     */
     refreshUpdatedAt(updatedAt: Date): PromiseOr<void>;
+    /**
+     * Refresh Digest
+     * Prefer `refreshUpdateMetadata` in most cases
+     *
+     * @param digest Content Digest
+     */
     refreshDigest(digest: string): PromiseOr<void>;
+    /**
+     * Add a history record
+     * Prefer `refreshUpdateMetadata` in most cases
+     *
+     * @param record History Record
+     */
     addHistoryRecord(record: ImbricatePageHistoryRecord): PromiseOr<void>;
 }

package/page-variant/definition.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @author WMXPY
+ * @namespace PageVariant
+ * @description Definition
+ */
+export declare enum IMBRICATE_PAGE_VARIANT_LANGUAGE {
+    TEXT = "text",
+    MARKDOWN = "markdown",
+    LATEX = "latex"
+}
+export declare const IMBRICATE_PAGE_VARIANT_LANGUAGE_LIST: IMBRICATE_PAGE_VARIANT_LANGUAGE[];
+export declare const isValidImbricatePageVariantLanguage: (language: unknown) => language is IMBRICATE_PAGE_VARIANT_LANGUAGE;
+export type ImbricatePageVariant = {
+    readonly language: IMBRICATE_PAGE_VARIANT_LANGUAGE;
+};
+export declare const isImbricatePageVariant: (variant: unknown) => variant is ImbricatePageVariant;

package/page-variant/definition.js

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace PageVariant
+ * @description Definition
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isImbricatePageVariant = exports.isValidImbricatePageVariantLanguage = exports.IMBRICATE_PAGE_VARIANT_LANGUAGE_LIST = exports.IMBRICATE_PAGE_VARIANT_LANGUAGE = void 0;
+var IMBRICATE_PAGE_VARIANT_LANGUAGE;
+(function (IMBRICATE_PAGE_VARIANT_LANGUAGE) {
+    IMBRICATE_PAGE_VARIANT_LANGUAGE["TEXT"] = "text";
+    IMBRICATE_PAGE_VARIANT_LANGUAGE["MARKDOWN"] = "markdown";
+    IMBRICATE_PAGE_VARIANT_LANGUAGE["LATEX"] = "latex";
+})(IMBRICATE_PAGE_VARIANT_LANGUAGE || (exports.IMBRICATE_PAGE_VARIANT_LANGUAGE = IMBRICATE_PAGE_VARIANT_LANGUAGE = {}));
+exports.IMBRICATE_PAGE_VARIANT_LANGUAGE_LIST = [
+    IMBRICATE_PAGE_VARIANT_LANGUAGE.TEXT,
+    IMBRICATE_PAGE_VARIANT_LANGUAGE.MARKDOWN,
+    IMBRICATE_PAGE_VARIANT_LANGUAGE.LATEX,
+];
+const isValidImbricatePageVariantLanguage = (language) => {
+    return exports.IMBRICATE_PAGE_VARIANT_LANGUAGE_LIST.includes(language);
+};
+exports.isValidImbricatePageVariantLanguage = isValidImbricatePageVariantLanguage;
+const isImbricatePageVariant = (variant) => {
+    if (typeof variant !== "object") {
+        return false;
+    }
+    if (!(0, exports.isValidImbricatePageVariantLanguage)(variant.language)) {
+        return false;
+    }
+    return true;
+};
+exports.isImbricatePageVariant = isImbricatePageVariant;

package/script/base.d.ts

@@ -6,7 +6,7 @@
 import { ImbricateCapabilityBuilder } from "../capability/builder";
 import { ImbricateCapability } from "../capability/definition";
 import type { PromiseOr } from "../definition/promise";
-import { IMBRICATE_EXECUTABLE_VARIANT, ImbricateExecuteEnvironment, ImbricateExecuteParameters, ImbricateExecuteResult } from "../execute/definition";
+import { ImbricateScriptVariant } from "../script-variant/definition";
 import { IMBRICATE_SCRIPT_CAPABILITY_KEY, ImbricateScriptAttributes, ImbricateScriptCapability, ImbricateScriptHistoryRecord } from "./definition";
 import type { IImbricateScript } from "./interface";
 export declare abstract class ImbricateScriptBase implements IImbricateScript {
@@ -15,7 +15,7 @@ export declare abstract class ImbricateScriptBase implements IImbricateScript {
     static allDenyCapability(): ImbricateScriptCapability;
     abstract readonly scriptName: string;
     abstract readonly identifier: string;
-    abstract readonly variant: IMBRICATE_EXECUTABLE_VARIANT;
+    abstract readonly variant: ImbricateScriptVariant;
     abstract readonly digest: string;
     abstract readonly historyRecords: ImbricateScriptHistoryRecord[];
     abstract readonly description?: string;
@@ -30,5 +30,4 @@ export declare abstract class ImbricateScriptBase implements IImbricateScript {
     refreshUpdatedAt(_updatedAt: Date): PromiseOr<void>;
     refreshDigest(_digest: string): PromiseOr<void>;
     addHistoryRecord(_record: ImbricateScriptHistoryRecord): PromiseOr<void>;
-    execute(_parameters: ImbricateExecuteParameters, _environment: ImbricateExecuteEnvironment): PromiseOr<ImbricateExecuteResult>;
 }

package/script/base.js

@@ -44,8 +44,5 @@ class ImbricateScriptBase {
     addHistoryRecord(_record) {
         throw not_implemented_1.ImbricateNotImplemented.create("AddHistoryRecord", definition_2.IMBRICATE_SCRIPT_CAPABILITY_KEY.UPDATE_HISTORY_RECORD);
     }
-    execute(_parameters, _environment) {
-        throw not_implemented_1.ImbricateNotImplemented.create("Execute", definition_2.IMBRICATE_SCRIPT_CAPABILITY_KEY.EXECUTE);
-    }
 }
 exports.ImbricateScriptBase = ImbricateScriptBase;

package/script/definition.d.ts

@@ -4,7 +4,7 @@
  * @description Definition
  */
 import { ImbricateCapability } from "../capability/definition";
-import { IMBRICATE_EXECUTABLE_VARIANT } from "../execute/definition";
+import { ImbricateScriptVariant } from "../script-variant/definition";
 import { IMBRICATE_SEARCH_RESULT_TYPE, ImbricateSearchResult, ImbricateSearchSnippet } from "../search/snippet";
 export type ImbricateScriptAttributes = Record<string, string>;
 export type ImbricateScriptSearchResult = ImbricateSearchResult<IMBRICATE_SEARCH_RESULT_TYPE.SCRIPT>;
@@ -12,16 +12,17 @@ export type ImbricateScriptSearchSnippet = ImbricateSearchSnippet<IMBRICATE_SEAR
 export type ImbricateScriptSnapshot = {
     readonly scriptName: string;
     readonly identifier: string;
-    readonly variant: IMBRICATE_EXECUTABLE_VARIANT;
+    readonly variant: ImbricateScriptVariant;
 };
 export type ImbricateScriptHistoryRecord = {
-    readonly updatedAt: Date;
+    readonly author: string;
     readonly digest: string;
+    readonly updatedAt: Date;
 };
 export type ImbricateScriptMetadata = {
     readonly createdAt: Date;
-    readonly updatedAt: Date;
     readonly digest: string;
+    readonly updatedAt: Date;
     readonly attributes: ImbricateScriptAttributes;
     readonly historyRecords: ImbricateScriptHistoryRecord[];
     readonly description?: string;

package/script/interface.d.ts

@@ -4,12 +4,12 @@
  * @description Interface
  */
 import { PromiseOr } from "../definition/promise";
-import { IMBRICATE_EXECUTABLE_VARIANT, ImbricateExecuteEnvironment, ImbricateExecuteParameters, ImbricateExecuteResult } from "../execute/definition";
+import { ImbricateScriptVariant } from "../script-variant/definition";
 import { ImbricateScriptAttributes, ImbricateScriptCapability, ImbricateScriptHistoryRecord } from "./definition";
 export interface IImbricateScript {
     readonly scriptName: string;
     readonly identifier: string;
-    readonly variant: IMBRICATE_EXECUTABLE_VARIANT;
+    readonly variant: ImbricateScriptVariant;
     readonly digest: string;
     readonly historyRecords: ImbricateScriptHistoryRecord[];
     readonly description?: string;
@@ -20,9 +20,33 @@ export interface IImbricateScript {
     writeScript(script: string): PromiseOr<void>;
     readAttributes(): PromiseOr<ImbricateScriptAttributes>;
     writeAttribute(key: string, value: string): PromiseOr<void>;
+    /**
+     * Refresh Updated At and Digest, and add a history record
+     * Recommended to use this method when updating the script
+     *
+     * @param updatedAt Updated At
+     * @param digest Content Digest
+     */
     refreshUpdateMetadata(updatedAt: Date, digest: string): PromiseOr<void>;
+    /**
+     * Refresh Updated At
+     * Prefer `refreshUpdateMetadata` in most cases
+     *
+     * @param updatedAt Updated At
+     */
     refreshUpdatedAt(updatedAt: Date): PromiseOr<void>;
+    /**
+     * Refresh Digest
+     * Prefer `refreshUpdateMetadata` in most cases
+     *
+     * @param digest Content Digest
+     */
     refreshDigest(digest: string): PromiseOr<void>;
+    /**
+     * Add a history record
+     * Prefer `refreshUpdateMetadata` in most cases
+     *
+     * @param record History Record
+     */
     addHistoryRecord(record: ImbricateScriptHistoryRecord): PromiseOr<void>;
-    execute(parameters: ImbricateExecuteParameters, environment: ImbricateExecuteEnvironment): PromiseOr<ImbricateExecuteResult>;
 }

package/script-manager/base.d.ts

@@ -6,9 +6,9 @@
 import { ImbricateCapabilityBuilder } from "../capability/builder";
 import { ImbricateCapability } from "../capability/definition";
 import type { PromiseOr } from "../definition/promise";
-import { IMBRICATE_EXECUTABLE_VARIANT, ImbricateExecuteEnvironment, ImbricateExecuteParameters, ImbricateExecuteResult } from "../execute/definition";
 import { ImbricateScriptQuery, ImbricateScriptQueryConfig, ImbricateSearchScriptConfig } from "../query/script";
 import { IImbricateScriptManager } from "../script-manager/interface";
+import { ImbricateScriptVariant } from "../script-variant/definition";
 import { ImbricateScriptMetadata, ImbricateScriptSearchResult, ImbricateScriptSnapshot } from "../script/definition";
 import { IImbricateScript } from "../script/interface";
 import { IMBRICATE_SCRIPT_MANAGER_CAPABILITY_KEY, ImbricateScriptManagerCapability } from "./definition";
@@ -17,7 +17,7 @@ export declare abstract class ImbricateScriptManagerBase implements IImbricateSc
     static allAllowCapability(): ImbricateScriptManagerCapability;
     static allDenyCapability(): ImbricateScriptManagerCapability;
     abstract readonly capabilities: ImbricateScriptManagerCapability;
-    createScript(_scriptName: string, _variant: IMBRICATE_EXECUTABLE_VARIANT, _initialScript: string, _description?: string): PromiseOr<IImbricateScript>;
+    createScript(_scriptName: string, _variant: ImbricateScriptVariant, _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>;
@@ -26,5 +26,4 @@ export declare abstract class ImbricateScriptManagerBase implements IImbricateSc
     listScripts(): PromiseOr<ImbricateScriptSnapshot[]>;
     searchScripts(_keyword: string, _config: ImbricateSearchScriptConfig): PromiseOr<ImbricateScriptSearchResult[]>;
     queryScripts(_query: ImbricateScriptQuery, _config: ImbricateScriptQueryConfig): PromiseOr<IImbricateScript[]>;
-    executeScriptSnippet(_snippet: string, _variant: IMBRICATE_EXECUTABLE_VARIANT, _parameters: ImbricateExecuteParameters, _environment: ImbricateExecuteEnvironment): PromiseOr<ImbricateExecuteResult>;
 }

package/script-manager/base.js

@@ -47,8 +47,5 @@ class ImbricateScriptManagerBase {
     queryScripts(_query, _config) {
         throw not_implemented_1.ImbricateNotImplemented.create("QueryScripts", definition_2.IMBRICATE_SCRIPT_MANAGER_CAPABILITY_KEY.LIST_SCRIPTS);
     }
-    executeScriptSnippet(_snippet, _variant, _parameters, _environment) {
-        throw not_implemented_1.ImbricateNotImplemented.create("ExecuteScriptSnippet", definition_2.IMBRICATE_SCRIPT_MANAGER_CAPABILITY_KEY.EXECUTE_SCRIPT_SNIPPET);
-    }
 }
 exports.ImbricateScriptManagerBase = ImbricateScriptManagerBase;

package/script-manager/interface.d.ts

@@ -4,8 +4,8 @@
  * @description Interface
  */
 import { PromiseOr } from "../definition/promise";
-import { IMBRICATE_EXECUTABLE_VARIANT, ImbricateExecuteEnvironment, ImbricateExecuteParameters, ImbricateExecuteResult } from "../execute/definition";
 import { ImbricateScriptQuery, ImbricateScriptQueryConfig, ImbricateSearchScriptConfig } from "../query/script";
+import { ImbricateScriptVariant } from "../script-variant/definition";
 import { ImbricateScriptMetadata, ImbricateScriptSearchResult, ImbricateScriptSnapshot } from "../script/definition";
 import { IImbricateScript } from "../script/interface";
 import { ImbricateScriptManagerCapability } from "./definition";
@@ -23,7 +23,15 @@ export interface IImbricateScriptManager {
      *
      * @returns Created script
      */
-    createScript(scriptName: string, variant: IMBRICATE_EXECUTABLE_VARIANT, initialScript: string, description?: string): PromiseOr<IImbricateScript>;
+    createScript(scriptName: string, variant: ImbricateScriptVariant, initialScript: string, description?: string): PromiseOr<IImbricateScript>;
+    /**
+     * Put a script
+     *
+     * @param scriptMetadata the metadata of the script
+     * @param script the script content
+     *
+     * @returns the script
+     */
     putScript(scriptMetadata: ImbricateScriptMetadata, script: string): PromiseOr<IImbricateScript>;
     renameScript(identifier: string, newScriptName: string): PromiseOr<void>;
     deleteScript(identifier: string): PromiseOr<void>;
@@ -32,5 +40,4 @@ export interface IImbricateScriptManager {
     listScripts(): PromiseOr<ImbricateScriptSnapshot[]>;
     searchScripts(keyword: string, config: ImbricateSearchScriptConfig): PromiseOr<ImbricateScriptSearchResult[]>;
     queryScripts(query: ImbricateScriptQuery, config: ImbricateScriptQueryConfig): PromiseOr<IImbricateScript[]>;
-    executeScriptSnippet(snippet: string, variant: IMBRICATE_EXECUTABLE_VARIANT, parameters: ImbricateExecuteParameters, environment: ImbricateExecuteEnvironment): PromiseOr<ImbricateExecuteResult>;
 }

package/script-variant/definition.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @author WMXPY
+ * @namespace ScriptVariant
+ * @description Definition
+ */
+export declare enum IMBRICATE_SCRIPT_LANGUAGE {
+    JAVASCRIPT = "javascript",
+    TYPESCRIPT = "typescript"
+}
+export declare const IMBRICATE_SCRIPT_LANGUAGE_LIST: IMBRICATE_SCRIPT_LANGUAGE[];
+export declare const isValidImbricateScriptLanguage: (language: unknown) => language is IMBRICATE_SCRIPT_LANGUAGE;
+export type ImbricateScriptVariant = {
+    readonly language: IMBRICATE_SCRIPT_LANGUAGE;
+    readonly engine: string;
+};
+export declare const isImbricateScriptVariant: (variant: unknown) => variant is ImbricateScriptVariant;

package/script-variant/definition.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace ScriptVariant
+ * @description Definition
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isImbricateScriptVariant = exports.isValidImbricateScriptLanguage = exports.IMBRICATE_SCRIPT_LANGUAGE_LIST = exports.IMBRICATE_SCRIPT_LANGUAGE = void 0;
+var IMBRICATE_SCRIPT_LANGUAGE;
+(function (IMBRICATE_SCRIPT_LANGUAGE) {
+    IMBRICATE_SCRIPT_LANGUAGE["JAVASCRIPT"] = "javascript";
+    IMBRICATE_SCRIPT_LANGUAGE["TYPESCRIPT"] = "typescript";
+})(IMBRICATE_SCRIPT_LANGUAGE || (exports.IMBRICATE_SCRIPT_LANGUAGE = IMBRICATE_SCRIPT_LANGUAGE = {}));
+exports.IMBRICATE_SCRIPT_LANGUAGE_LIST = [
+    IMBRICATE_SCRIPT_LANGUAGE.JAVASCRIPT,
+    IMBRICATE_SCRIPT_LANGUAGE.TYPESCRIPT,
+];
+const isValidImbricateScriptLanguage = (language) => {
+    return exports.IMBRICATE_SCRIPT_LANGUAGE_LIST.includes(language);
+};
+exports.isValidImbricateScriptLanguage = isValidImbricateScriptLanguage;
+const isImbricateScriptVariant = (variant) => {
+    if (typeof variant !== "object") {
+        return false;
+    }
+    if (!(0, exports.isValidImbricateScriptLanguage)(variant.language)) {
+        return false;
+    }
+    if (typeof variant.engine !== "string") {
+        return false;
+    }
+    return true;
+};
+exports.isImbricateScriptVariant = isImbricateScriptVariant;

package/script-variant/extension.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @author WMXPY
+ * @namespace ScriptVariant
+ * @description Extension
+ */
+import { IMBRICATE_SCRIPT_LANGUAGE } from "./definition";
+export declare const getImbricateScriptLanguageExtension: (language: IMBRICATE_SCRIPT_LANGUAGE, withDot?: boolean) => string;

package/script-variant/extension.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace ScriptVariant
+ * @description Extension
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getImbricateScriptLanguageExtension = void 0;
+const definition_1 = require("./definition");
+const fixExtension = (extension, withDot) => {
+    if (withDot) {
+        return `.${extension}`;
+    }
+    return extension;
+};
+const getImbricateScriptLanguageExtension = (language, withDot = true) => {
+    switch (language) {
+        case definition_1.IMBRICATE_SCRIPT_LANGUAGE.JAVASCRIPT: return fixExtension("js", withDot);
+        case definition_1.IMBRICATE_SCRIPT_LANGUAGE.TYPESCRIPT: return fixExtension("ts", withDot);
+    }
+    return fixExtension("unknown", withDot);
+};
+exports.getImbricateScriptLanguageExtension = getImbricateScriptLanguageExtension;

package/execute/extension.d.ts

@@ -1,7 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Execute
- * @description Extension
- */
-import { IMBRICATE_EXECUTABLE_VARIANT } from "./definition";
-export declare const getImbricateExecutableExtension: (variant: IMBRICATE_EXECUTABLE_VARIANT, withDot?: boolean) => string;

package/execute/extension.js

@@ -1,23 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace Execute
- * @description Extension
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getImbricateExecutableExtension = void 0;
-const definition_1 = require("./definition");
-const fixExtension = (extension, withDot) => {
-    if (withDot) {
-        return `.${extension}`;
-    }
-    return extension;
-};
-const getImbricateExecutableExtension = (variant, withDot = true) => {
-    switch (variant) {
-        case definition_1.IMBRICATE_EXECUTABLE_VARIANT.JAVASCRIPT_NODE: return fixExtension("js", withDot);
-        case definition_1.IMBRICATE_EXECUTABLE_VARIANT.TYPESCRIPT_NODE: return fixExtension("ts", withDot);
-    }
-    return fixExtension("unknown", withDot);
-};
-exports.getImbricateExecutableExtension = getImbricateExecutableExtension;