SOF-7756-2: Units + Context Providers dist

dist/js/ExecutionUnitInput.d.ts

@@ -0,0 +1,28 @@
+import { Template } from "@mat3ra/ade";
+import { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { AnyObject } from "@mat3ra/esse/dist/js/esse/types";
+import type { TemplateSchema } from "@mat3ra/esse/dist/js/types";
+import type { ContextItem } from "./context/providers/base/ContextProvider";
+import type ContextProvider from "./context/providers/base/ContextProvider";
+import type { ExecutionUnitInputSchemaMixin } from "./generated/ExecutionUnitInputSchemaMixin";
+type Schema = ExecutionUnitInputSchemaMixin;
+type Base = typeof InMemoryEntity & Constructor<ExecutionUnitInputSchemaMixin>;
+type ConstructorConfig = Schema | (Omit<Schema, "template"> & {
+    template: Template;
+});
+declare const ExecutionUnitInput_base: Base;
+export default class ExecutionUnitInput extends ExecutionUnitInput_base implements Schema {
+    _json: Schema & AnyObject;
+    toJSON: () => Schema & AnyObject;
+    toJSONQuick: () => Schema & AnyObject;
+    static get jsonSchema(): import("json-schema").JSONSchema7 | undefined;
+    contextProvidersInstances: ContextProvider[];
+    readonly templateInstance: Template;
+    static createFromTemplate(template: Template | TemplateSchema): ExecutionUnitInput;
+    constructor(config: ConstructorConfig);
+    setContext(context: ContextItem[]): this;
+    render(): this;
+    getFullContext(): import("./context/providers/base/ContextProvider").ExtendedContextItem<string, object, object>[];
+}
+export {};

dist/js/ExecutionUnitInput.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ade_1 = require("@mat3ra/ade");
+const entity_1 = require("@mat3ra/code/dist/js/entity");
+const JSONSchemasInterface_1 = __importDefault(require("@mat3ra/esse/dist/js/esse/JSONSchemasInterface"));
+const nunjucks_1 = __importDefault(require("nunjucks"));
+const providers_1 = require("./context/providers");
+class ExecutionUnitInput extends entity_1.InMemoryEntity {
+    static get jsonSchema() {
+        return JSONSchemasInterface_1.default.getSchemaById("workflow/unit/input/-inputItem");
+    }
+    static createFromTemplate(template) {
+        return new ExecutionUnitInput({
+            template,
+            rendered: template.content,
+            isManuallyChanged: false,
+        });
+    }
+    constructor(config) {
+        const { template } = config;
+        const templateInstance = template instanceof ade_1.Template ? template : new ade_1.Template(template);
+        super({ ...config, template: templateInstance.toJSON() });
+        this.contextProvidersInstances = [];
+        this.templateInstance = templateInstance;
+    }
+    setContext(context) {
+        this.contextProvidersInstances = this.template.contextProviders.map(({ name }) => {
+            if (!providers_1.providers) {
+                throw new Error("Providers config not set");
+            }
+            const ContextProvider = providers_1.providers[name];
+            const contextItem = context.find((c) => c.name === name);
+            if (!contextItem) {
+                throw new Error(`Context item for provider ${name} not found`);
+            }
+            return new ContextProvider(contextItem);
+        });
+        return this;
+    }
+    render() {
+        if (this.isManuallyChanged) {
+            return this;
+        }
+        const fullContext = this.getFullContext();
+        const rendered = nunjucks_1.default.compile(this.template.content).render(fullContext);
+        this.rendered = rendered || this.template.content;
+        return this;
+    }
+    getFullContext() {
+        return this.contextProvidersInstances.map((contextProvider) => {
+            return contextProvider.getContextItem();
+        });
+    }
+}
+exports.default = ExecutionUnitInput;

dist/js/RuntimeItemsUILogicMixin.d.ts

@@ -0,0 +1,27 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { RuntimeItems } from "@mat3ra/code/dist/js/entity/mixins/RuntimeItemsMixin";
+import type { NameResultSchema } from "@mat3ra/code/dist/js/utils/object";
+import type { RuntimeItemsSchema } from "@mat3ra/esse/dist/js/types";
+type ItemKey = "results" | "monitors" | "preProcessors" | "postProcessors";
+export type RuntimeItemsUILogic = {
+    setRuntimeItemsToDefaultValues(): void;
+    _initRuntimeItems(config?: Partial<RuntimeItemsSchema>): void;
+    toggleRuntimeItem(key: ItemKey, data: NameResultSchema, isAdding: boolean): void;
+    toggleResult(data: NameResultSchema, isAdding: boolean): void;
+    toggleMonitor(data: NameResultSchema, isAdding: boolean): void;
+    togglePreProcessor(data: NameResultSchema, isAdding: boolean): void;
+    togglePostProcessor(data: NameResultSchema, isAdding: boolean): void;
+    getResultByName(name: string): NameResultSchema | undefined;
+    get resultNames(): string[];
+    get monitorNames(): string[];
+    get postProcessorNames(): string[];
+    get preProcessorNames(): string[];
+};
+type Base = InMemoryEntity & RuntimeItems & {
+    defaultResults: NameResultSchema[];
+    defaultMonitors: NameResultSchema[];
+    defaultPreProcessors: NameResultSchema[];
+    defaultPostProcessors: NameResultSchema[];
+};
+export declare function runtimeItemsUILogicMixin<T extends Base>(item: T): void;
+export {};

dist/js/RuntimeItemsUILogicMixin.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runtimeItemsUILogicMixin = runtimeItemsUILogicMixin;
+// @ts-expect-error
+const propertiesMixn = {
+    setRuntimeItemsToDefaultValues() {
+        this.results = this.defaultResults;
+        this.monitors = this.defaultMonitors;
+        this.preProcessors = this.defaultPreProcessors;
+        this.postProcessors = this.defaultPostProcessors;
+    },
+    _initRuntimeItems(config) {
+        this.results = (config === null || config === void 0 ? void 0 : config.results) || this.defaultResults;
+        this.monitors = (config === null || config === void 0 ? void 0 : config.monitors) || this.defaultMonitors;
+        this.preProcessors = (config === null || config === void 0 ? void 0 : config.preProcessors) || this.defaultPreProcessors;
+        this.postProcessors = (config === null || config === void 0 ? void 0 : config.postProcessors) || this.defaultPostProcessors;
+    },
+    toggleRuntimeItem(key, data, isAdding) {
+        if (isAdding) {
+            this[key] = [...this[key], data];
+        }
+        else {
+            this[key] = this[key].filter((x) => x.name !== data.name);
+        }
+    },
+    toggleResult(data, isAdding) {
+        this.toggleRuntimeItem("results", data, isAdding);
+    },
+    toggleMonitor(data, isAdding) {
+        this.toggleRuntimeItem("monitors", data, isAdding);
+    },
+    togglePreProcessor(data, isAdding) {
+        this.toggleRuntimeItem("preProcessors", data, isAdding);
+    },
+    togglePostProcessor(data, isAdding) {
+        this.toggleRuntimeItem("postProcessors", data, isAdding);
+    },
+    get resultNames() {
+        return this.results.map((r) => r.name);
+    },
+    get monitorNames() {
+        return this.monitors.map((r) => r === null || r === void 0 ? void 0 : r.name);
+    },
+    get postProcessorNames() {
+        return this.postProcessors.map((r) => r.name);
+    },
+    get preProcessorNames() {
+        return this.preProcessors.map((r) => r.name);
+    },
+    getResultByName(name) {
+        return this.results.find((r) => r.name === name);
+    },
+};
+function runtimeItemsUILogicMixin(item) {
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(propertiesMixn));
+}

dist/js/context/mixins/ApplicationContextMixin.d.ts

@@ -0,0 +1,10 @@
+import type { Application } from "@mat3ra/ade";
+import type ContextProvider from "../providers/base/ContextProvider";
+export type ApplicationContextMixin = {
+    readonly application: Application;
+    initApplicationContextMixin(externalContext: ApplicationExternalContext): void;
+};
+export type ApplicationExternalContext = {
+    application?: Application;
+};
+export declare function applicationContextMixin(item: ContextProvider): void;

dist/js/context/mixins/ApplicationContextMixin.js

@@ -1,19 +1,15 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.applicationContextMixin = applicationContextMixin;
-var _settings = require("../providers/settings");
+const settings_1 = require("../providers/settings");
 function applicationContextMixin(item) {
-  const properties = {
-    _application: undefined,
-    initApplicationContextMixin() {
-      this._application = this.config.context && this.config.context.application || _settings.globalSettings.Application.createDefault();
-    },
-    get application() {
-      return this._application;
-    }
-  };
-  Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
-}
+    // @ts-expect-error
+    const properties = {
+        initApplicationContextMixin(externalContext) {
+            var _a;
+            this.application =
+                (_a = externalContext.application) !== null && _a !== void 0 ? _a : settings_1.globalSettings.Application.createDefault();
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

dist/js/context/mixins/ContextAndRenderFieldsMixin.d.ts

@@ -0,0 +1,17 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { AnyObject } from "@mat3ra/esse/dist/js/esse/types";
+export type Context = AnyObject;
+export type ContextMixin = {
+    context: Context;
+    renderingContext: Context;
+    getRenderingContext(): Context;
+    updateRenderingContext(ctx: Context): void;
+    getPersistentContext(): Context;
+    updatePersistentContext(ctx: Context): void;
+    getCombinedContext(): Context;
+};
+type AbstractBase = {
+    render(ctx: Context): void;
+};
+export declare function contextMixin<T extends InMemoryEntity & AbstractBase>(item: T): asserts item is T & ContextMixin;
+export {};

dist/js/context/mixins/ContextAndRenderFieldsMixin.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contextMixin = contextMixin;
+function contextMixin(item) {
+    // @ts-expect-error
+    const properties = {
+        get context() {
+            return this.requiredProp("context");
+        },
+        set context(ctx) {
+            this.setProp("context", ctx);
+        },
+        renderingContext: {},
+        updateRenderingContext(ctx) {
+            this.context = { ...this.renderingContext, ...ctx };
+        },
+        getRenderingContext() {
+            return this.renderingContext;
+        },
+        getPersistentContext() {
+            return this.context;
+        },
+        updatePersistentContext(ctx) {
+            this.context = { ...ctx };
+        },
+        getCombinedContext() {
+            return {
+                ...this.getPersistentContext(),
+                ...this.getRenderingContext(),
+            };
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

dist/js/context/mixins/ImportantSettingsProviderMixin.d.ts

@@ -0,0 +1,17 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+export interface ContextProvider {
+    domain?: string;
+}
+export type ImportantSettingsProvider = {
+    important: object;
+    setImportant(key: string, value: unknown): void;
+    importantSettingsProviders: ContextProvider[];
+    isImportantEdited: boolean | undefined;
+};
+type AbstractBase = {
+    contextProviders: ContextProvider[];
+};
+export type ImportantSettingsProviderInMemoryEntityConstructor = Constructor<ImportantSettingsProvider>;
+export declare function importantSettingsProviderMixin<T extends InMemoryEntity & AbstractBase>(item: T): asserts item is T & ImportantSettingsProvider;
+export {};

dist/js/context/mixins/ImportantSettingsProviderMixin.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importantSettingsProviderMixin = importantSettingsProviderMixin;
+const clone_1 = require("@mat3ra/code/dist/js/utils/clone");
+function importantSettingsProviderMixin(item) {
+    // @ts-expect-error
+    const properties = {
+        get important() {
+            return (0, clone_1.deepClone)(this._json.important || {});
+        },
+        setImportant(key, value) {
+            this.setProp("important", { [key]: value });
+        },
+        get importantSettingsProviders() {
+            return this.contextProviders.filter((p) => p.domain === "important");
+        },
+        get isImportantEdited() {
+            return this.prop("important.isEdited");
+        },
+        set isImportantEdited(bool) {
+            this.setProp("important", Object.assign(this.important, { isEdited: bool }));
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

dist/js/context/mixins/JobContextMixin.d.ts

@@ -0,0 +1,11 @@
+import type { JobSchema } from "@mat3ra/esse/dist/js/types";
+import type ContextProvider from "../providers/base/ContextProvider";
+export type JobContextMixin = {
+    isEdited: boolean;
+    job: JobSchema;
+    initJobContextMixin(externalContext: JobExternalContext): void;
+};
+export type JobExternalContext = {
+    job: JobSchema;
+};
+export default function jobContextMixin(item: ContextProvider): void;