@imbricate/core 1.30.0 → 1.32.0

package/capability/builder.js

@@ -29,11 +29,9 @@ class ImbricateCapabilityBuilder {
         return this;
     }
     build() {
-        return Object.keys(this._capabilities).map((key) => {
-            return {
-                [key]: this._capabilities[key],
-            };
-        });
+        return Object.keys(this._capabilities).reduce((previous, current) => {
+            return Object.assign(Object.assign({}, previous), { [current]: this._capabilities[current] });
+        }, {});
     }
 }
 exports.ImbricateCapabilityBuilder = ImbricateCapabilityBuilder;

package/capability/create.d.ts

@@ -3,5 +3,5 @@
  * @namespace Capability
  * @description Create
  */
-import type { ImbricateCapability, ImbricateCapabilityRecord } from "./definition";
-export declare const createImbricateCapabilityRecord: <T extends string>(list: T[], initialValue: ImbricateCapability) => ImbricateCapabilityRecord<T>;
+import type { ImbricateCapability, ImbricateCapabilityKey, ImbricateCapabilityRecord } from "./definition";
+export declare const createImbricateCapabilityRecord: <T extends ImbricateCapabilityKey>(list: T[], initialValue: ImbricateCapability) => ImbricateCapabilityRecord<T>;

package/capability/validate.js

@@ -11,9 +11,6 @@ const validateImbricateCapability = (capabilities, capability) => {
     if (!capabilities) {
         return false;
     }
-    if (!Array.isArray(capabilities)) {
-        return false;
-    }
     const capabilityValue = capabilities[capability];
     if (!capabilityValue) {
         return false;

package/execute/definition.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @author WMXPY
+ * @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 enum IMBRICATE_EXECUTE_RESULT_CODE {
+    NOT_SUPPORT = "NOT_SUPPORT",
+    SUCCESS = "SUCCESS",
+    ERROR = "ERROR",
+    EXCEPTION = "EXCEPTION",
+    TIMEOUT = "TIMEOUT"
+}
+export type ImbricateExecuteResult = {
+    readonly code: IMBRICATE_EXECUTE_RESULT_CODE;
+};
+export type ImbricateExecuteParameters = Record<string, any>;
+export type ImbricateExecuteEnvironment = Record<string, any>;

package/execute/definition.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Execute
+ * @description Definition
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IMBRICATE_EXECUTE_RESULT_CODE = 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,
+];
+var IMBRICATE_EXECUTE_RESULT_CODE;
+(function (IMBRICATE_EXECUTE_RESULT_CODE) {
+    IMBRICATE_EXECUTE_RESULT_CODE["NOT_SUPPORT"] = "NOT_SUPPORT";
+    IMBRICATE_EXECUTE_RESULT_CODE["SUCCESS"] = "SUCCESS";
+    IMBRICATE_EXECUTE_RESULT_CODE["ERROR"] = "ERROR";
+    IMBRICATE_EXECUTE_RESULT_CODE["EXCEPTION"] = "EXCEPTION";
+    IMBRICATE_EXECUTE_RESULT_CODE["TIMEOUT"] = "TIMEOUT";
+})(IMBRICATE_EXECUTE_RESULT_CODE || (exports.IMBRICATE_EXECUTE_RESULT_CODE = IMBRICATE_EXECUTE_RESULT_CODE = {}));

package/execute/extension.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @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

@@ -0,0 +1,23 @@
+"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;

package/index.d.ts

@@ -20,6 +20,8 @@ export * from "./definition/listable";
 export * from "./definition/promise";
 export * from "./error/imbricate-error";
 export * from "./error/not-implemented";
+export * from "./execute/definition";
+export * from "./execute/extension";
 export * from "./function/base";
 export * from "./function/definition";
 export * from "./function/interface";
@@ -32,12 +34,6 @@ export * from "./page/interface";
 export * from "./query/definition";
 export * from "./query/page";
 export * from "./query/script";
-export * from "./sandbox/definition/config";
-export * from "./sandbox/definition/environment";
-export * from "./sandbox/definition/implementation";
-export * from "./sandbox/feature/builder";
-export * from "./sandbox/feature/feature";
-export * from "./sandbox/sandbox";
 export * from "./script-manager/base";
 export * from "./script-manager/definition";
 export * from "./script-manager/interface";

package/index.js

@@ -36,6 +36,8 @@ __exportStar(require("./definition/listable"), exports);
 __exportStar(require("./definition/promise"), exports);
 __exportStar(require("./error/imbricate-error"), exports);
 __exportStar(require("./error/not-implemented"), 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);
@@ -48,12 +50,6 @@ __exportStar(require("./page/interface"), exports);
 __exportStar(require("./query/definition"), exports);
 __exportStar(require("./query/page"), exports);
 __exportStar(require("./query/script"), exports);
-__exportStar(require("./sandbox/definition/config"), exports);
-__exportStar(require("./sandbox/definition/environment"), exports);
-__exportStar(require("./sandbox/definition/implementation"), exports);
-__exportStar(require("./sandbox/feature/builder"), exports);
-__exportStar(require("./sandbox/feature/feature"), exports);
-__exportStar(require("./sandbox/sandbox"), exports);
 __exportStar(require("./script-manager/base"), exports);
 __exportStar(require("./script-manager/definition"), exports);
 __exportStar(require("./script-manager/interface"), exports);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@imbricate/core",
   "main": "index.js",
-  "version": "1.30.0",
+  "version": "1.32.0",
   "description": "Imbricate Core, Notebook for Engineers",
   "repository": {
     "type": "git",
@@ -17,15 +17,5 @@
   "bugs": {
     "url": "https://github.com/Imbricate/Imbricate/issues"
   },
-  "homepage": "https://imbricate.io",
-  "dependencies": {
-    "@sudoo/marked-mixin-date": "1.0.0",
-    "@sudoo/marked-mixin-json": "1.0.0",
-    "@sudoo/marked-mixin-math": "1.4.0",
-    "@sudoo/marked-mixin-object": "1.3.0",
-    "@sudoo/marked-mixin-parse": "1.0.0"
-  },
-  "peerDependencies": {
-    "@sudoo/marked": "*"
-  }
+  "homepage": "https://imbricate.io"
 }

package/page/definition.d.ts

@@ -8,10 +8,14 @@ import { IMBRICATE_SEARCH_RESULT_TYPE, ImbricateSearchResult, ImbricateSearchSni
 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 {
+    MARKDOWN = "markdown"
+}
 export type ImbricatePageSnapshot = {
     readonly title: string;
     readonly directories: string[];
     readonly identifier: string;
+    readonly variant: IMBRICATE_PAGE_VARIANT;
 };
 export type ImbricatePageHistoryRecord = {
     readonly updatedAt: Date;

package/page/definition.js

@@ -5,7 +5,11 @@
  * @description Definition
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImbricatePageCapabilityList = exports.IMBRICATE_PAGE_CAPABILITY_KEY = void 0;
+exports.ImbricatePageCapabilityList = exports.IMBRICATE_PAGE_CAPABILITY_KEY = exports.IMBRICATE_PAGE_VARIANT = void 0;
+var IMBRICATE_PAGE_VARIANT;
+(function (IMBRICATE_PAGE_VARIANT) {
+    IMBRICATE_PAGE_VARIANT["MARKDOWN"] = "markdown";
+})(IMBRICATE_PAGE_VARIANT || (exports.IMBRICATE_PAGE_VARIANT = IMBRICATE_PAGE_VARIANT = {}));
 var IMBRICATE_PAGE_CAPABILITY_KEY;
 (function (IMBRICATE_PAGE_CAPABILITY_KEY) {
     IMBRICATE_PAGE_CAPABILITY_KEY["READ"] = "imbricate.page.read";

package/script/base.d.ts

@@ -3,12 +3,10 @@
  * @namespace Script
  * @description Base
  */
-import type { MarkedResult } from "@sudoo/marked";
 import { ImbricateCapabilityBuilder } from "../capability/builder";
 import { ImbricateCapability } from "../capability/definition";
 import type { PromiseOr } from "../definition/promise";
-import type { SandboxExecuteConfig, SandboxExecuteParameter } from "../sandbox/definition/config";
-import type { SandboxFeature } from "../sandbox/feature/feature";
+import { ImbricateExecuteEnvironment, ImbricateExecuteParameters, ImbricateExecuteResult } from "../execute/definition";
 import { IMBRICATE_SCRIPT_CAPABILITY_KEY, ImbricateScriptAttributes, ImbricateScriptCapability, ImbricateScriptHistoryRecord } from "./definition";
 import type { IImbricateScript } from "./interface";
 export declare abstract class ImbricateScriptBase implements IImbricateScript {
@@ -31,5 +29,5 @@ export declare abstract class ImbricateScriptBase implements IImbricateScript {
     refreshUpdatedAt(_updatedAt: Date): PromiseOr<void>;
     refreshDigest(_digest: string): PromiseOr<void>;
     addHistoryRecord(_record: ImbricateScriptHistoryRecord): PromiseOr<void>;
-    execute(_features: SandboxFeature[], _config: SandboxExecuteConfig, _parameter: SandboxExecuteParameter): PromiseOr<MarkedResult>;
+    execute(_parameters: ImbricateExecuteParameters, _environment: ImbricateExecuteEnvironment): PromiseOr<ImbricateExecuteResult>;
 }

package/script/base.js

@@ -44,7 +44,7 @@ class ImbricateScriptBase {
     addHistoryRecord(_record) {
         throw not_implemented_1.ImbricateNotImplemented.create("AddHistoryRecord", definition_2.IMBRICATE_SCRIPT_CAPABILITY_KEY.UPDATE_HISTORY_RECORD);
     }
-    execute(_features, _config, _parameter) {
+    execute(_parameters, _environment) {
         throw not_implemented_1.ImbricateNotImplemented.create("Execute", definition_2.IMBRICATE_SCRIPT_CAPABILITY_KEY.EXECUTE);
     }
 }

package/script/definition.d.ts

@@ -4,6 +4,7 @@
  * @description Definition
  */
 import { ImbricateCapability } from "../capability/definition";
+import { IMBRICATE_EXECUTABLE_VARIANT } from "../execute/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>;
@@ -11,6 +12,7 @@ export type ImbricateScriptSearchSnippet = ImbricateSearchSnippet<IMBRICATE_SEAR
 export type ImbricateScriptSnapshot = {
     readonly scriptName: string;
     readonly identifier: string;
+    readonly variant: IMBRICATE_EXECUTABLE_VARIANT;
 };
 export type ImbricateScriptHistoryRecord = {
     readonly updatedAt: Date;

package/script/interface.d.ts

@@ -3,11 +3,9 @@
  * @namespace Script
  * @description Interface
  */
-import { MarkedResult } from "@sudoo/marked";
 import { PromiseOr } from "../definition/promise";
-import { SandboxExecuteConfig, SandboxExecuteParameter } from "../sandbox/definition/config";
-import { SandboxFeature } from "../sandbox/feature/feature";
 import { ImbricateScriptAttributes, ImbricateScriptCapability, ImbricateScriptHistoryRecord } from "./definition";
+import { ImbricateExecuteEnvironment, ImbricateExecuteParameters, ImbricateExecuteResult } from "../execute/definition";
 export interface IImbricateScript {
     readonly scriptName: string;
     readonly identifier: string;
@@ -25,5 +23,5 @@ export interface IImbricateScript {
     refreshUpdatedAt(updatedAt: Date): PromiseOr<void>;
     refreshDigest(digest: string): PromiseOr<void>;
     addHistoryRecord(record: ImbricateScriptHistoryRecord): PromiseOr<void>;
-    execute(features: SandboxFeature[], config: SandboxExecuteConfig, parameter: SandboxExecuteParameter): PromiseOr<MarkedResult>;
+    execute(parameters: ImbricateExecuteParameters, environment: ImbricateExecuteEnvironment): PromiseOr<ImbricateExecuteResult>;
 }

package/script-manager/base.d.ts

@@ -3,15 +3,13 @@
  * @namespace ScriptManager
  * @description Base
  */
-import { MarkedResult } from "@sudoo/marked";
 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 { SandboxExecuteConfig, SandboxExecuteParameter } from "../sandbox/definition/config";
-import { SandboxFeature } from "../sandbox/feature/feature";
 import { IImbricateScriptManager } from "../script-manager/interface";
-import { ImbricateScriptMetadata, ImbricateScriptSnapshot } from "../script/definition";
+import { ImbricateScriptMetadata, ImbricateScriptSearchResult, ImbricateScriptSnapshot } from "../script/definition";
 import { IImbricateScript } from "../script/interface";
 import { IMBRICATE_SCRIPT_MANAGER_CAPABILITY_KEY, ImbricateScriptManagerCapability } from "./definition";
 export declare abstract class ImbricateScriptManagerBase implements IImbricateScriptManager {
@@ -26,7 +24,7 @@ export declare abstract class ImbricateScriptManagerBase implements IImbricateSc
     hasScript(_scriptName: string): PromiseOr<boolean>;
     getScript(_identifier: string): PromiseOr<IImbricateScript | null>;
     listScripts(): PromiseOr<ImbricateScriptSnapshot[]>;
-    searchScripts(_keyword: string, _config: ImbricateSearchScriptConfig): PromiseOr<any[]>;
+    searchScripts(_keyword: string, _config: ImbricateSearchScriptConfig): PromiseOr<ImbricateScriptSearchResult[]>;
     queryScripts(_query: ImbricateScriptQuery, _config: ImbricateScriptQueryConfig): PromiseOr<IImbricateScript[]>;
-    executeScriptSnippet(_snippet: string, _features: SandboxFeature[], _config: SandboxExecuteConfig, _parameter: SandboxExecuteParameter): PromiseOr<MarkedResult>;
+    executeScriptSnippet(_snippet: string, _variant: IMBRICATE_EXECUTABLE_VARIANT, _parameters: ImbricateExecuteParameters, _environment: ImbricateExecuteEnvironment): PromiseOr<ImbricateExecuteResult>;
 }

package/script-manager/base.js

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

package/script-manager/interface.d.ts

@@ -3,11 +3,9 @@
  * @namespace ScriptManager
  * @description Interface
  */
-import { MarkedResult } from "@sudoo/marked";
 import { PromiseOr } from "../definition/promise";
+import { IMBRICATE_EXECUTABLE_VARIANT, ImbricateExecuteEnvironment, ImbricateExecuteParameters, ImbricateExecuteResult } from "../execute/definition";
 import { ImbricateScriptQuery, ImbricateScriptQueryConfig, ImbricateSearchScriptConfig } from "../query/script";
-import { SandboxExecuteConfig, SandboxExecuteParameter } from "../sandbox/definition/config";
-import { SandboxFeature } from "../sandbox/feature/feature";
 import { ImbricateScriptMetadata, ImbricateScriptSearchResult, ImbricateScriptSnapshot } from "../script/definition";
 import { IImbricateScript } from "../script/interface";
 import { ImbricateScriptManagerCapability } from "./definition";
@@ -34,5 +32,5 @@ export interface IImbricateScriptManager {
     listScripts(): PromiseOr<ImbricateScriptSnapshot[]>;
     searchScripts(keyword: string, config: ImbricateSearchScriptConfig): PromiseOr<ImbricateScriptSearchResult[]>;
     queryScripts(query: ImbricateScriptQuery, config: ImbricateScriptQueryConfig): PromiseOr<IImbricateScript[]>;
-    executeScriptSnippet(snippet: string, features: SandboxFeature[], config: SandboxExecuteConfig, parameter: SandboxExecuteParameter): PromiseOr<MarkedResult>;
+    executeScriptSnippet(snippet: string, variant: IMBRICATE_EXECUTABLE_VARIANT, parameters: ImbricateExecuteParameters, environment: ImbricateExecuteEnvironment): PromiseOr<ImbricateExecuteResult>;
 }

package/sandbox/definition/config.d.ts

@@ -1,7 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Sandbox_Definition
- * @description Config
- */
-export type SandboxExecuteConfig = Record<string, any>;
-export type SandboxExecuteParameter = Record<string, any>;

package/sandbox/definition/config.js

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

package/sandbox/definition/environment.d.ts

@@ -1,11 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Sandbox_Definition
- * @description Environment
- */
-export type SandboxEnvironmentOrigin = {
-    readonly type: string;
-};
-export type SandboxEnvironment = {
-    readonly origin: SandboxEnvironmentOrigin;
-};

package/sandbox/definition/environment.js

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

package/sandbox/definition/implementation.d.ts

@@ -1,6 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Sandbox_Definition
- * @description Implementation
- */
-export type SandboxImplementation = (...args: any[]) => Promise<any> | any;

package/sandbox/definition/implementation.js

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

package/sandbox/feature/builder.d.ts

@@ -1,22 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Sandbox_Feature
- * @description Builder
- */
-import { SandboxImplementation } from "../definition/implementation";
-import { SandboxFeature } from "./feature";
-export declare class SandboxFeatureBuilder {
-    static providedByOrigin(): SandboxFeatureBuilder;
-    static providedBySandbox(): SandboxFeatureBuilder;
-    static providedByInterface(): SandboxFeatureBuilder;
-    static providedBy(providedBy: string): SandboxFeatureBuilder;
-    private readonly _provideBy;
-    private _packageName;
-    private _methodName;
-    private _implementation;
-    private constructor();
-    withPackageName(packageName: string): this;
-    withMethodName(methodName: string): this;
-    withImplementation(implementation: SandboxImplementation): this;
-    build(): SandboxFeature;
-}

package/sandbox/feature/builder.js

@@ -1,45 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace Sandbox_Feature
- * @description Builder
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SandboxFeatureBuilder = void 0;
-const feature_1 = require("./feature");
-class SandboxFeatureBuilder {
-    static providedByOrigin() {
-        return new SandboxFeatureBuilder("origin");
-    }
-    static providedBySandbox() {
-        return new SandboxFeatureBuilder("sandbox");
-    }
-    static providedByInterface() {
-        return new SandboxFeatureBuilder("interface");
-    }
-    static providedBy(providedBy) {
-        return new SandboxFeatureBuilder(providedBy);
-    }
-    constructor(provideBy) {
-        this._provideBy = provideBy;
-        this._packageName = "";
-        this._methodName = "";
-        this._implementation = () => null;
-    }
-    withPackageName(packageName) {
-        this._packageName = packageName;
-        return this;
-    }
-    withMethodName(methodName) {
-        this._methodName = methodName;
-        return this;
-    }
-    withImplementation(implementation) {
-        this._implementation = implementation;
-        return this;
-    }
-    build() {
-        return feature_1.SandboxFeature.create(`${this._provideBy}:${this._packageName}`, this._methodName, this._implementation);
-    }
-}
-exports.SandboxFeatureBuilder = SandboxFeatureBuilder;

package/sandbox/feature/feature.d.ts

@@ -1,16 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Sandbox_Feature
- * @description Feature
- */
-import { SandboxImplementation } from "../definition/implementation";
-export declare class SandboxFeature {
-    static create(packageName: string, methodName: string, implementation: SandboxImplementation): SandboxFeature;
-    private readonly _packageName;
-    private readonly _methodName;
-    private readonly _implementation;
-    private constructor();
-    get packageName(): string;
-    get methodName(): string;
-    get implementation(): SandboxImplementation;
-}

package/sandbox/feature/feature.js

@@ -1,28 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace Sandbox_Feature
- * @description Feature
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SandboxFeature = void 0;
-class SandboxFeature {
-    static create(packageName, methodName, implementation) {
-        return new SandboxFeature(packageName, methodName, implementation);
-    }
-    constructor(packageName, methodName, implementation) {
-        this._packageName = packageName;
-        this._methodName = methodName;
-        this._implementation = implementation;
-    }
-    get packageName() {
-        return this._packageName;
-    }
-    get methodName() {
-        return this._methodName;
-    }
-    get implementation() {
-        return this._implementation;
-    }
-}
-exports.SandboxFeature = SandboxFeature;

package/sandbox/provide/feature.d.ts

@@ -1,8 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Sandbox_Provide
- * @description Feature
- */
-import { Sandbox } from "@sudoo/marked";
-import { SandboxFeature } from "../feature/feature";
-export declare const sandboxProvideFeatures: (sandbox: Sandbox, features: SandboxFeature[]) => void;

package/sandbox/provide/feature.js

@@ -1,26 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace Sandbox_Provide
- * @description Feature
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sandboxProvideFeatures = void 0;
-const mapFeatures = (features) => {
-    const map = {};
-    for (const feature of features) {
-        if (!map[feature.packageName]) {
-            map[feature.packageName] = {};
-        }
-        map[feature.packageName][feature.methodName] = feature.implementation;
-    }
-    return map;
-};
-const sandboxProvideFeatures = (sandbox, features) => {
-    const mappedFeatures = mapFeatures(features);
-    for (const packageName of Object.keys(mappedFeatures)) {
-        const methods = mappedFeatures[packageName];
-        sandbox.provide(packageName, methods);
-    }
-};
-exports.sandboxProvideFeatures = sandboxProvideFeatures;

package/sandbox/sandbox.d.ts

@@ -1,11 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Sandbox
- * @description Sandbox
- */
-import { MarkedResult, Sandbox } from "@sudoo/marked";
-import { SandboxExecuteConfig, SandboxExecuteParameter } from "./definition/config";
-import { SandboxEnvironment } from "./definition/environment";
-import { SandboxFeature } from "./feature/feature";
-export declare const createSandbox: (features: SandboxFeature[]) => Sandbox;
-export declare const executeSandboxScript: (script: string, features: SandboxFeature[], environment: SandboxEnvironment, configuration: SandboxExecuteConfig, parameters: SandboxExecuteParameter) => Promise<MarkedResult>;

package/sandbox/sandbox.js

@@ -1,43 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace Sandbox
- * @description Sandbox
- */
-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.executeSandboxScript = exports.createSandbox = void 0;
-const marked_1 = require("@sudoo/marked");
-const marked_mixin_date_1 = require("@sudoo/marked-mixin-date");
-const marked_mixin_json_1 = require("@sudoo/marked-mixin-json");
-const marked_mixin_math_1 = require("@sudoo/marked-mixin-math");
-const marked_mixin_object_1 = require("@sudoo/marked-mixin-object");
-const marked_mixin_parse_1 = require("@sudoo/marked-mixin-parse");
-const feature_1 = require("./provide/feature");
-const createSandbox = (features) => {
-    const sandbox = marked_1.Sandbox.fromAllEvaluators();
-    sandbox.use(marked_mixin_date_1.markedDateMixinFactory.createInjectMixin("Date"));
-    sandbox.use(marked_mixin_json_1.markedJsonMixinFactory.createInjectMixin("Json"));
-    sandbox.use(marked_mixin_math_1.markedMathMixinFactory.createInjectMixin("Math"));
-    sandbox.use(marked_mixin_object_1.markedObjectMixinFactory.createInjectMixin("Object"));
-    sandbox.use(marked_mixin_parse_1.markedParseMixinFactory.createInjectMixin("Parse"));
-    (0, feature_1.sandboxProvideFeatures)(sandbox, features);
-    return sandbox;
-};
-exports.createSandbox = createSandbox;
-const executeSandboxScript = (script, features, environment, configuration, parameters) => __awaiter(void 0, void 0, void 0, function* () {
-    const sandbox = (0, exports.createSandbox)(features);
-    sandbox.inject("environment", environment);
-    sandbox.inject("configuration", configuration);
-    sandbox.inject("parameters", parameters);
-    return yield sandbox.evaluate(script);
-});
-exports.executeSandboxScript = executeSandboxScript;