@evergis/react 4.0.166 → 4.0.168

package/dist/dashboardActions/index.js

@@ -0,0 +1,577 @@
+'use strict';
+
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+const BINARY_PRECEDENCE = {
+    "||": 1,
+    "&&": 2,
+    "===": 3,
+    "!==": 3,
+    "==": 3,
+    "!=": 3,
+    ">": 4,
+    ">=": 4,
+    "<": 4,
+    "<=": 4,
+    "+": 5,
+    "-": 5,
+    "*": 6,
+    "/": 6,
+    "%": 6,
+};
+const UNARY_PRECEDENCE = 7;
+const CONDITION_TOKEN = new RegExp([
+    String.raw `^(?:(\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)|`,
+    String.raw `((?:#[\w]+|\$(?:event|params)(?:\.(?!includes\b)[\w]+)*|`,
+    String.raw `\$(?:dashboard|card):[\w]+(?::[\w]+)?|%[\w]+(?:\.(?!includes\b)[\w]+)?|\{[^{}]+\}))|`,
+    String.raw `(===|!==|>=|<=|==|!=|&&|\|\||[+*/%<>!()[\],.-])|(true|false|null|Date\.parse|includes)\b)`,
+].join(""));
+
+// Грамматика подстановок независима от React и графиков: она нужна также проверке JSON-конфигов.
+const FILTER_PREFIX = "%";
+const PROVIDER_PREFIX = "$";
+var ProviderPrefix;
+(function (ProviderPrefix) {
+    /** `$card:<слой>:<поле>` — атрибут объекта карточки. */
+    ProviderPrefix["Card"] = "card";
+    /**
+     * Ближайший дашборд, в ряд к `%` своего виджета: `$dashboard:<фильтр>[.свойство]` — его фильтр,
+     * `$dashboard:<датасорс>:<поле>` — поле первой строки его датасорса.
+     */
+    ProviderPrefix["Dashboard"] = "dashboard";
+})(ProviderPrefix || (ProviderPrefix = {}));
+/**
+ * Имя слоя или датасорса в подстановке: буквы, цифры, `_`, `.` и `-`. Более широкий класс захватил бы
+ * соседний токен: `$dashboard:a.min–$dashboard:a.max` читался бы как датасорс `a.min–$dashboard`.
+ */
+const CONFIG_SOURCE_NAME = "[\\w.-]+";
+/**
+ * Все подстановки строки конфига одной грамматикой, по группам:
+ * 1–2 `$dashboard:<датасорс>:<поле>`, 3–4 `$dashboard:<фильтр>[.свойство]`, 5–6 `$card:<слой>:<поле>`,
+ * 7–8 `%<фильтр>[.свойство]`, 9 `{<атрибут>}`. Форма датасорса проверяется раньше формы фильтра:
+ * их различает второе двоеточие. Имя фильтра — `\w+` целиком, поэтому `%name` не цепляет начало
+ * `%name2`, а точка в конце предложения («за %year.») не считается свойством.
+ */
+const CONFIG_TOKEN_REGEXP = new RegExp([
+    `\\${PROVIDER_PREFIX}${ProviderPrefix.Dashboard}:(${CONFIG_SOURCE_NAME}):(\\w+)`,
+    `\\${PROVIDER_PREFIX}${ProviderPrefix.Dashboard}:(\\w+)(?:\\.(\\w+))?`,
+    `\\${PROVIDER_PREFIX}${ProviderPrefix.Card}:(${CONFIG_SOURCE_NAME}):(\\w+)`,
+    `${FILTER_PREFIX}(\\w+)(?:\\.(\\w+))?`,
+    "\\{([^{}\\s]+)\\}",
+].join("|"), "g");
+
+const toToken = ([raw, ...groups]) => {
+    const [dataSourceName, dataSourceField, dashboardFilter, dashboardProp, cardLayer, cardField, filterName, filterProp, attributeName, resultPath, eventPath, parametersPath,] = groups;
+    if (resultPath || raw.startsWith("$event") || raw.startsWith("$params")) {
+        return { kind: "action", scope: resultPath ? "result" : raw.startsWith("$event") ? "event" : "parameters", path: resultPath || eventPath || parametersPath || "", raw };
+    }
+    if (dataSourceName) {
+        return { kind: "dataSource", dataSourceName, fieldName: dataSourceField, raw };
+    }
+    if (dashboardFilter) {
+        return { kind: "filter", scope: "dashboard", name: dashboardFilter, prop: dashboardProp, raw };
+    }
+    if (cardLayer) {
+        return { kind: "card", layerName: cardLayer, fieldName: cardField, raw };
+    }
+    if (filterName) {
+        return { kind: "filter", scope: "widget", name: filterName, prop: filterProp, raw };
+    }
+    return { kind: "attribute", name: attributeName, raw };
+};
+/** Разбирает строку конфига на литералы и токены подстановок — в исходном порядке. */
+const tokenizeConfigString = (value) => {
+    const segments = [];
+    let lastIndex = 0;
+    for (const match of value.matchAll(new RegExp(`${CONFIG_TOKEN_REGEXP.source}|#([\\w]+(?:\\.[\\w]+)*)|\\$event(?:\\.([\\w]+(?:\\.[\\w]+)*))?\\b|\\$params(?:\\.([\\w]+(?:\\.[\\w]+)*))?\\b`, "g"))) {
+        const token = toToken(match);
+        const escaped = match.index > 0 && value[match.index - 1] === "\\";
+        if (escaped) {
+            segments.push(value.slice(lastIndex, match.index - 1), match[0]);
+            lastIndex = match.index + match[0].length;
+            continue;
+        }
+        if (token.kind === "action" && match.index > 0 && /[\w/#?=.-]/.test(value[match.index - 1]))
+            continue;
+        if (match.index > lastIndex) {
+            segments.push(value.slice(lastIndex, match.index));
+        }
+        segments.push(token);
+        lastIndex = match.index + match[0].length;
+    }
+    if (lastIndex < value.length) {
+        segments.push(value.slice(lastIndex));
+    }
+    return segments;
+};
+/** Строка целиком — один токен: тогда значение уходит как есть, с типом (число, массив). */
+const getSingleToken = (segments) => segments.length === 1 && typeof segments[0] !== "string" ? segments[0] : null;
+
+// Строковые литералы читаются отдельно: префиксы подстановок внутри кавычек остаются обычным текстом.
+const readString = (input) => {
+    const quote = input[0];
+    let value = "";
+    let index = 1;
+    while (index < input.length) {
+        const character = input[index++];
+        if (character === quote)
+            return { kind: "literal", text: input.slice(0, index), value };
+        if (character !== "\\") {
+            value += character;
+            continue;
+        }
+        const escaped = input[index++];
+        const escapes = { n: "\n", r: "\r", t: "\t", "\\": "\\", "'": "'", "\"": "\"" };
+        if (!(escaped in escapes))
+            throw new Error("Unsupported string escape");
+        value += escapes[escaped];
+    }
+    throw new Error("Unterminated string");
+};
+const readToken = (input, expectsOperand) => {
+    if (input[0] === "'" || input[0] === "\"")
+        return readString(input);
+    // % в начале операнда — фильтр, после значения — остаток от деления.
+    if (input[0] === "%" && !expectsOperand)
+        return { kind: "operator", text: "%" };
+    const match = input.match(CONDITION_TOKEN);
+    if (!match) {
+        const property = input.match(/^[A-Za-z_][\w]*/);
+        if (property)
+            return { kind: "operator", text: property[0] };
+        throw new Error(`Unexpected token: ${input[0]}`);
+    }
+    const [text, number, reference, operator, keyword] = match;
+    if (number)
+        return { kind: "literal", text, value: Number(number) };
+    if (reference) {
+        // Формат ссылки разбирает общий механизм конфигов; здесь определяется только её граница в выражении.
+        const token = getSingleToken(tokenizeConfigString(text));
+        if (!token)
+            throw new Error(`Invalid reference: ${text}`);
+        return { kind: "reference", text, reference: token };
+    }
+    if (keyword === "null")
+        return { kind: "literal", text, value: null };
+    if (keyword === "true" || keyword === "false")
+        return { kind: "literal", text, value: keyword === "true" };
+    return { kind: "operator", text: operator ?? keyword };
+};
+const tokenizeActionCondition = (expression) => {
+    const tokens = [];
+    let remaining = expression.trim();
+    let expectsOperand = true;
+    while (remaining) {
+        const token = readToken(remaining, expectsOperand);
+        tokens.push(token);
+        remaining = remaining.slice(token.text.length).trimStart();
+        expectsOperand = token.kind === "operator" && ![")", "]"].includes(token.text);
+    }
+    return tokens;
+};
+
+/**
+ * Разбирает ограниченное выражение: приоритеты операторов, скобки, свойства, includes и Date.parse.
+ * Условия источников данных лишь форматируются для сервера; callback требует вычисления в браузере.
+ */
+const parseActionCondition = (condition) => {
+    const tokens = tokenizeActionCondition(condition);
+    let position = 0;
+    const peekToken = () => tokens[position]?.text;
+    function expectToken(text) {
+        if (peekToken() !== text)
+            throw new Error(`Expected ${text}`);
+        position++;
+    }
+    // Литерал или начало выражения: ссылка, унарный оператор, скобки, массив, разрешённый вызов.
+    function parsePrimary() {
+        const token = tokens[position++];
+        if (!token)
+            throw new Error("Expected expression");
+        if (token.kind === "literal")
+            return { kind: "literal", value: token.value };
+        if (token.kind === "reference")
+            return { kind: "reference", token: token.reference };
+        if (["!", "+", "-"].includes(token.text))
+            return { kind: "unary", operator: token.text, operand: parseExpression(UNARY_PRECEDENCE) };
+        if (token.text === "(") {
+            const node = parseExpression(0);
+            expectToken(")");
+            return node;
+        }
+        if (token.text === "[")
+            return parseArray();
+        if (token.text === "Date.parse") {
+            expectToken("(");
+            const argument = parseExpression(0);
+            expectToken(")");
+            return { kind: "date", argument };
+        }
+        throw new Error(`Unsupported identifier: ${token.text}`);
+    }
+    function parseArray() {
+        const items = [];
+        while (peekToken() !== "]") {
+            items.push(parseExpression(0));
+            if (peekToken() !== ",")
+                break;
+            position++;
+        }
+        expectToken("]");
+        return { kind: "array", items };
+    }
+    // После значения разрешены лишь чтение поля/индекса и includes; произвольные методы не вызываются.
+    function parsePostfix(initial) {
+        let node = initial;
+        while (peekToken() === "." || peekToken() === "[") {
+            const operator = tokens[position++].text;
+            if (operator === "[") {
+                node = { kind: "property", target: node, key: parseExpression(0) };
+                expectToken("]");
+                continue;
+            }
+            const name = tokens[position++]?.text;
+            if (!name || !/^[A-Za-z_]\w*$/.test(name))
+                throw new Error("Invalid property");
+            if (name === "includes" && peekToken() === "(") {
+                position++;
+                node = { kind: "includes", target: node, argument: parseExpression(0) };
+                expectToken(")");
+            }
+            else
+                node = { kind: "property", target: node, key: { kind: "literal", value: name } };
+        }
+        return node;
+    }
+    // Правый операнд читает операторы с большим приоритетом; одинаковый приоритет вычисляется слева направо.
+    function parseExpression(minimum) {
+        let left = parsePostfix(parsePrimary());
+        while ((BINARY_PRECEDENCE[peekToken()] ?? -1) >= minimum) {
+            const operator = tokens[position++].text;
+            const right = parseExpression(BINARY_PRECEDENCE[operator] + 1);
+            left = { kind: "binary", operator, left, right };
+        }
+        return left;
+    }
+    const result = parseExpression(0);
+    if (position !== tokens.length)
+        throw new Error("Unexpected trailing tokens");
+    return result;
+};
+
+const ACTION_TYPES = ["runTask", "setFilters", "openUrl", "openModal"];
+const UNSAFE_ACTION_KEYS = new Set(["__proto__", "prototype", "constructor"]);
+
+const mergeActionParameters = (base, override) => {
+    if (!isObject(override)) {
+        if (Array.isArray(override))
+            return override.map(value => mergeActionParameters(undefined, value));
+        return override;
+    }
+    const result = {};
+    const original = isObject(base) ? base : {};
+    for (const key of new Set([...Object.keys(original), ...Object.keys(override)])) {
+        if (UNSAFE_ACTION_KEYS.has(key))
+            continue;
+        result[key] = Object.prototype.hasOwnProperty.call(override, key)
+            ? mergeActionParameters(original[key], override[key])
+            : mergeActionParameters(undefined, original[key]);
+    }
+    return result;
+};
+
+const resolveActionInvocation = (invocation, scopes) => {
+    if (invocation.type)
+        return { ...invocation, event: invocation.event ?? "click" };
+    const definition = [...scopes]
+        .reverse()
+        .flatMap(scope => scope)
+        .find(({ id }) => id === invocation.id);
+    if (!definition)
+        throw new Error(`Unknown action: ${invocation.id}`);
+    return {
+        ...definition,
+        options: mergeActionParameters(definition.options, invocation.options ?? {}),
+        event: invocation.event ?? definition.event ?? "click",
+        callback: Object.prototype.hasOwnProperty.call(invocation, "callback") ? invocation.callback : definition.callback,
+    };
+};
+
+const isFilterScalar = (value) => value === null ||
+    typeof value === "string" ||
+    typeof value === "boolean" ||
+    (typeof value === "number" && Number.isFinite(value)) ||
+    (value instanceof Date && Number.isFinite(value.getTime()));
+const isTreeValue = (value) => Object.entries(value).every(([level, ids]) => /^l\d+$/.test(level) && Array.isArray(ids) && ids.every(id => typeof id === "string" || typeof id === "number"));
+const isFeaturesValue = (value) => value.type === "FeatureCollection" &&
+    Array.isArray(value.features) &&
+    value.features.every(feature => isObject(feature) &&
+        feature.type === "Feature" &&
+        feature.geometry === null &&
+        isObject(feature.properties));
+const isFilterValue = (value) => {
+    if (isFilterScalar(value))
+        return true;
+    if (Array.isArray(value))
+        return value.every(isFilterScalar);
+    return isObject(value) && (isTreeValue(value) || isFeaturesValue(value));
+};
+const isActionSelectedFilter = (filter) => {
+    if (!isObject(filter) || !["value", "min", "max"].some(key => key in filter))
+        return false;
+    if ("value" in filter && !isFilterValue(filter.value))
+        return false;
+    if ("min" in filter && !isFilterScalar(filter.min))
+        return false;
+    if ("max" in filter && !isFilterScalar(filter.max))
+        return false;
+    return true;
+};
+
+const getActionShapeError = (action, definition) => {
+    if (definition && (typeof action.id !== "string" || !action.id))
+        return "Definition requires an id";
+    if (!definition && action.id !== undefined && action.type !== undefined)
+        return "Invocation must be either a reference or inline action";
+    if (Object.prototype.hasOwnProperty.call(action, "parameters"))
+        return "Action parameters have been renamed to options";
+    if (action.event !== undefined && action.event !== "click")
+        return "Unknown action event";
+    if (action.type === undefined && !definition) {
+        if (typeof action.id !== "string" || !action.id)
+            return "Invocation requires id or type";
+        if (action.options !== undefined && !isObject(action.options))
+            return "Options must be an object";
+        return undefined;
+    }
+    if (!ACTION_TYPES.includes(action.type))
+        return "Unknown action type";
+    return getActionOptionsError(action.type, action.options);
+};
+function getActionOptionsError(type, value) {
+    if (!isObject(value))
+        return "Options must be an object";
+    if (type === "runTask" && (typeof value.taskName !== "string" || !value.taskName))
+        return "runTask requires taskName";
+    if (type === "openModal" && (typeof value.modalId !== "string" || !value.modalId))
+        return "openModal requires modalId";
+    if (type === "openUrl" && (typeof value.url !== "string" || !value.url))
+        return "openUrl requires url";
+    if (type === "openUrl" && value.target !== undefined && !["_self", "_blank"].includes(String(value.target)))
+        return "Invalid URL target";
+    if (["runTask", "openModal"].includes(type) && value.parameters !== undefined && !isObject(value.parameters))
+        return "Nested parameters must be an object";
+    if (type === "setFilters") {
+        if (!isObject(value.filters))
+            return "setFilters requires filters object";
+        if (Object.values(value.filters).some(filter => !isActionSelectedFilter(filter)))
+            return "Invalid selected filter shape";
+    }
+    return undefined;
+}
+
+const addActionIssue = (state, frame, message, code = "invalidAction", severity = "error") => {
+    state.issues.push({ path: frame.path, ownerId: frame.ownerId, message, code, severity });
+};
+const validateResources = (action, frame, state) => {
+    if (!frame.declaration &&
+        action.type === "runTask" &&
+        frame.tasks &&
+        !frame.tasks.some(task => isObject(task) && task.name === action.options.taskName)) {
+        addActionIssue(state, frame, `Unknown task: ${action.options.taskName}`, "unknownTask");
+    }
+    if (action.type === "openModal" && !state.modalIds.has(action.options.modalId)) {
+        addActionIssue(state, frame, `Unknown modal: ${action.options.modalId}`, "unknownModal");
+    }
+    if (action.type === "openUrl" && action.options.target === "_self" && action.callback) {
+        addActionIssue(state, frame, "Navigation to _self may unload the callback", "navigationLifecycle", "warning");
+    }
+};
+const enqueueCallback = (callback, frame, pending, state) => {
+    const callbackFrame = { ...frame, path: `${frame.path}.callback`, definition: false };
+    if (!isObject(callback) || !Object.keys(callback).length) {
+        addActionIssue(state, callbackFrame, "Callback requires an invocation or condition map");
+        return;
+    }
+    if ("id" in callback || "type" in callback) {
+        pending.push({ ...callbackFrame, node: callback });
+        return;
+    }
+    for (const [condition, invocation] of Object.entries(callback)) {
+        const branch = { ...callbackFrame, path: `${callbackFrame.path}[${JSON.stringify(condition)}]` };
+        try {
+            if (condition !== "else")
+                parseActionCondition(condition);
+        }
+        catch {
+            addActionIssue(state, branch, "Invalid condition syntax", "invalidCondition");
+        }
+        if (isObject(invocation))
+            pending.push({ ...branch, node: invocation });
+        else
+            addActionIssue(state, branch, "Branch requires an invocation");
+    }
+};
+const validateActionTree = (initial, state) => {
+    const pending = [initial];
+    const visited = new Set();
+    while (pending.length) {
+        const frame = pending.pop();
+        if (!frame)
+            break;
+        const problem = getActionShapeError(frame.node, frame.definition);
+        if (problem) {
+            addActionIssue(state, frame, problem);
+            continue;
+        }
+        if (frame.declaration && !frame.node.type) {
+            if (!state.actionIds.has(String(frame.node.id)))
+                addActionIssue(state, frame, `Unknown action: ${String(frame.node.id)}`, "unknownAction");
+            if (frame.node.callback !== undefined)
+                enqueueCallback(frame.node.callback, frame, pending, state);
+            continue;
+        }
+        let action;
+        try {
+            action = frame.definition
+                ? { ...frame.node, event: frame.node.event ?? "click" }
+                : resolveActionInvocation(frame.node, frame.scopes);
+        }
+        catch {
+            addActionIssue(state, frame, `Unknown action: ${String(frame.node.id)}`, "unknownAction");
+            continue;
+        }
+        const optionsError = getActionOptionsError(action.type, action.options);
+        if (optionsError)
+            addActionIssue(state, frame, optionsError);
+        validateResources(action, frame, state);
+        const identity = frame.node.id
+            ? frame.scopes
+                .flatMap(scope => scope)
+                .reverse()
+                .find(definition => definition.id === frame.node.id)
+            : frame.node;
+        if (visited.has(identity))
+            continue;
+        visited.add(identity);
+        if (action.callback !== undefined)
+            enqueueCallback(action.callback, frame, pending, state);
+    }
+};
+const validateRegistry = (value, frame, state) => {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value)) {
+        addActionIssue(state, frame, "Actions must be an array");
+        return [];
+    }
+    const definitions = [];
+    const ids = new Set();
+    value.forEach((node, index) => {
+        const child = { ...frame, path: `${frame.path}[${index}]` };
+        if (!isObject(node)) {
+            addActionIssue(state, child, "Definition must be an object");
+            return;
+        }
+        const problem = getActionShapeError(node, true);
+        if (problem) {
+            addActionIssue(state, child, problem);
+            return;
+        }
+        const definition = node;
+        if (ids.has(definition.id))
+            addActionIssue(state, child, "Duplicate action id in scope", "duplicateAction");
+        ids.add(definition.id);
+        definitions.push(definition);
+    });
+    return definitions;
+};
+
+const withPath = (path, key) => (path ? `${path}.${key}` : key);
+const collectIds = (config, key) => {
+    const ids = new Set();
+    const pending = [config];
+    while (pending.length) {
+        const node = pending.pop();
+        if (!isObject(node))
+            continue;
+        if (Array.isArray(node[key])) {
+            for (const modal of node[key]) {
+                if (isObject(modal) && typeof modal.id === "string")
+                    ids.add(modal.id);
+            }
+            pending.push(...node[key]);
+        }
+        if (Array.isArray(node.children))
+            pending.push(...node.children);
+    }
+    return ids;
+};
+const validateBindings = (frame, state) => {
+    const { actions } = frame.node;
+    if (actions === undefined)
+        return;
+    if (!Array.isArray(actions)) {
+        addActionIssue(state, { ...frame, path: withPath(frame.path, "actions") }, "Actions must be an array");
+        return;
+    }
+    actions.forEach((node, index) => {
+        const child = { ...frame, path: `${withPath(frame.path, "actions")}[${index}]` };
+        if (isObject(node))
+            validateActionTree({ ...child, node }, state);
+        else
+            addActionIssue(state, child, "Action must be an object");
+    });
+};
+const enqueueChildren = (frame, pending) => {
+    for (const key of ["children", "modals"]) {
+        const children = frame.node[key];
+        if (!Array.isArray(children))
+            continue;
+        children.forEach((node, index) => {
+            if (!isObject(node))
+                return;
+            pending.push({
+                ...frame,
+                node,
+                path: `${withPath(frame.path, key)}[${index}]`,
+                definition: key === "modals" || frame.node.templateName === "Pages",
+            });
+        });
+    }
+    if (isObject(frame.node.header))
+        pending.push({ ...frame, node: frame.node.header, path: withPath(frame.path, "header"), definition: false });
+};
+/** Проверка JSON использует общий механизм разрешения действий и разбора условий. Циклы допустимы. */
+const validateDashboardActions = (config) => {
+    if (!isObject(config))
+        return [];
+    const state = {
+        issues: [],
+        modalIds: collectIds(config, "modals"),
+        actionIds: collectIds(config, "actions"),
+    };
+    const pending = [{ node: config, path: "", scopes: [], definition: true }];
+    while (pending.length) {
+        const frame = pending.pop();
+        if (!frame)
+            break;
+        frame.ownerId = typeof frame.node.id === "string" ? frame.node.id : frame.ownerId;
+        frame.tasks = Array.isArray(frame.node.tasks) ? frame.node.tasks : frame.tasks;
+        if (frame.definition) {
+            const definitions = validateRegistry(frame.node.actions, { ...frame, path: withPath(frame.path, "actions") }, state);
+            frame.scopes = [...frame.scopes, definitions];
+            definitions.forEach((node, index) => validateActionTree({ ...frame, node, declaration: true, path: `${withPath(frame.path, "actions")}[${index}]` }, state));
+        }
+        else {
+            validateBindings(frame, state);
+        }
+        enqueueChildren(frame, pending);
+    }
+    return state.issues;
+};
+
+exports.validateDashboardActions = validateDashboardActions;
+//# sourceMappingURL=index.js.map

package/dist/dashboardActions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/dashboardActions/package.json

@@ -0,0 +1 @@
+{"type":"commonjs","main":"index.js","types":"../dashboardActions.d.ts"}

package/dist/dashboardActions.d.ts

@@ -0,0 +1,3 @@
+/** Отдельная точка входа для проверки JSON и серверных инструментов работы с конфигурацией. */
+export { validateDashboardActions } from './components/Dashboard/actions/validation/validateDashboardActions';
+export type { ConfigActionDefinition, ConfigActionInvocation, ConfigActionCallback, ActionValidationIssue } from './components/Dashboard/actions/types';

package/dist/hooks/task/index.d.ts

@@ -3,3 +3,5 @@ export * from './usePythonTask';
 export * from './usePythonSandbox';
 export * from './useRemoteTask';
 export * from './types';
+export * from './runtime/types';
+export * from './runtime/startPythonExecution';

package/dist/hooks/task/runtime/PythonExecutionError.d.ts

@@ -0,0 +1,9 @@
+import { RemoteTaskStatus } from '@evergis/api';
+export declare class PythonExecutionError extends Error {
+    readonly runId: string;
+    readonly status: RemoteTaskStatus;
+    readonly taskId: string | null;
+    readonly cancelled: boolean;
+    notified: boolean;
+    constructor(message: string, runId: string, status: RemoteTaskStatus, taskId: string | null, cancelled?: boolean);
+}

package/dist/hooks/task/runtime/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const RUN_ID_RADIX = 36;
+export declare const TASK_OBSERVATION_TIMEOUT_MS = 86400000;

package/dist/hooks/task/runtime/resolvePythonTaskDefinition.d.ts

@@ -0,0 +1,2 @@
+import { PythonExecutionDependencies, PythonExecutionRequest, PythonTaskDefinition } from './types';
+export declare const resolvePythonTaskDefinition: (request: PythonExecutionRequest, manager: Pick<PythonExecutionDependencies["manager"], "getTaskResource">) => Promise<PythonTaskDefinition>;

package/dist/hooks/task/runtime/startPythonExecution.d.ts

@@ -0,0 +1,2 @@
+import { PythonExecutionDependencies, PythonExecutionHandle, PythonExecutionRequest } from './types';
+export declare const startPythonExecution: (request: PythonExecutionRequest, dependencies: PythonExecutionDependencies) => PythonExecutionHandle;

package/dist/hooks/task/runtime/types.d.ts

@@ -0,0 +1,53 @@
+import { Api, RemoteTaskStatus } from '@evergis/api';
+import { ConfigTask } from '../../../components/Dashboard/types';
+import { PythonTaskProgressNotification, PythonTaskProgressSubscription } from '../types';
+export interface PythonExecutionRequest {
+    taskName?: string;
+    tasks?: ConfigTask[];
+    resourceId?: string;
+    parameters?: Record<string, unknown>;
+    script?: string;
+    fileName?: string;
+    methodName?: string;
+    title?: string;
+    useNotifications?: boolean;
+    statusColors?: Record<RemoteTaskStatus, string>;
+}
+export interface PythonTaskDefinition {
+    resourceId: string;
+    parameters: Record<string, unknown>;
+    script?: string;
+    fileName?: string;
+    methodName?: string;
+}
+export interface PythonExecutionSnapshot {
+    taskId: string | null;
+    status: RemoteTaskStatus;
+    log: string | null;
+    lastMessage: string | null;
+    error: Error | null;
+    loading: boolean;
+    executionTime: number;
+    result: Record<string, unknown> | null;
+}
+export interface PythonExecutionHandle {
+    runId: string;
+    completion: Promise<Record<string, unknown>>;
+    getSnapshot: () => PythonExecutionSnapshot;
+    subscribe: (listener: () => void) => () => void;
+    stop: () => Promise<void>;
+}
+export interface PythonExecutionDependencies {
+    manager: Pick<Api["remoteTaskManager"], "createTaskPrototype" | "startTask1" | "get" | "stop" | "getTaskResource">;
+    prepare: (resource: {
+        resourceId: string;
+    }) => Promise<unknown>;
+    subscribe?: (payload: PythonTaskProgressSubscription) => Promise<string | null>;
+    unsubscribe?: (id: string) => void;
+    connection?: {
+        on: (event: string, callback: (notification: PythonTaskProgressNotification) => void) => void;
+        off: (event: string, callback: (notification: PythonTaskProgressNotification) => void) => void;
+    };
+    intervalMs?: number;
+    timeoutMs?: number;
+}