trigger_system 1.0.6 → 1.0.7

package/dist/lsp/domain/validator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"validator.d.ts","sourceRoot":"","sources":["../../../src/domain/validator.ts"],"names":[],"mappings":"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"}

package/dist/lsp/domain/validator.js

@@ -1,225 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TriggerValidator = exports.TriggerRuleSchema = exports.ActionGroupSchema = exports.ActionSchema = exports.RuleConditionSchema = exports.ConditionGroupSchema = exports.ConditionSchema = exports.ComparisonOperatorSchema = void 0;
-// src/domain/validator.ts
-const arktype_1 = require("arktype");
-// --- ArkType Scope & Schemas ---
-// Define a Validation Scope to handle recursive types and mutual dependencies
-const types = (0, arktype_1.scope)({
-    // List of allowed operators
-    Operator: "'EQ' | '==' | 'NEQ' | '!=' | 'GT' | '>' | 'GTE' | '>=' | 'LT' | '<' | 'LTE' | '<=' | 'IN' | 'NOT_IN' | 'CONTAINS' | 'MATCHES' | 'RANGE' | 'SINCE' | 'AFTER' | 'BEFORE' | 'UNTIL'",
-    // Discriminated union for better value validation based on operator
-    Condition: "RangeCondition | ListCondition | ContainsCondition | NumericCondition | RegexCondition | BasicCondition",
-    RangeCondition: {
-        field: "string > 0",
-        operator: "'RANGE'",
-        value: "unknown[] == 2" // Requires an array of exactly 2 items
-    },
-    ListCondition: {
-        field: "string > 0",
-        operator: "'IN' | 'NOT_IN'",
-        value: "unknown[]" // Requires an array
-    },
-    ContainsCondition: {
-        field: "string > 0",
-        operator: "'CONTAINS'",
-        value: "string | unknown[]" // Can be string (substring) or array (includes)
-    },
-    NumericCondition: {
-        field: "string > 0",
-        operator: "'>' | '>=' | '<' | '<=' | 'GT' | 'GTE' | 'LT' | 'LTE'",
-        value: "number | string" // Numbers or expressions
-    },
-    RegexCondition: {
-        field: "string > 0",
-        operator: "'MATCHES'",
-        value: "string" // Regex pattern must be a string
-    },
-    BasicCondition: {
-        field: "string > 0",
-        operator: "Operator",
-        value: "unknown"
-    },
-    ConditionGroup: {
-        operator: "'AND' | 'OR'",
-        // Recursive reference to Condition or ConditionGroup
-        conditions: "(Condition | ConditionGroup)[] >= 1" // Must have at least 1 condition
-    },
-    RuleCondition: "Condition | ConditionGroup",
-    Action: {
-        type: "string > 0", // Must define a type
-        "params?": "object", // Must be an object if present
-        "delay?": "number.integer >= 0", // Integer check for milliseconds
-        "probability?": "0 <= number <= 1"
-    },
-    ActionGroup: {
-        "mode?": "'ALL' | 'EITHER' | 'SEQUENCE'",
-        actions: "(Action | ActionGroup)[] >= 1" // Recursive
-    },
-    RuleAction: "Action | ActionGroup",
-    TriggerRule: {
-        id: "string > 0",
-        "name?": "string",
-        "description?": "string",
-        "priority?": "number.integer", // Priority is integer
-        "enabled?": "boolean",
-        "cooldown?": "number.integer >= 0", // Milliseconds
-        "tags?": "string[]",
-        on: "string > 0", // Non-empty event name
-        "if?": "RuleCondition | RuleCondition[]",
-        do: "RuleAction | RuleAction[]",
-        "comment?": "string"
-    }
-}).export();
-// Export individual schemas for external usage if needed
-exports.ComparisonOperatorSchema = types.Operator;
-exports.ConditionSchema = types.Condition;
-exports.ConditionGroupSchema = types.ConditionGroup;
-exports.RuleConditionSchema = types.RuleCondition;
-exports.ActionSchema = types.Action;
-exports.ActionGroupSchema = types.ActionGroup;
-exports.TriggerRuleSchema = types.TriggerRule;
-// --- Validator Class ---
-class TriggerValidator {
-    static validate(data) {
-        // ArkType validation
-        const out = (0, exports.TriggerRuleSchema)(data);
-        if (out instanceof arktype_1.type.errors) {
-            const issues = [];
-            // Iterate over problems (ArkType specific)
-            for (const problem of out) {
-                const path = problem.path.join(".");
-                let message = problem.message;
-                let suggestion = undefined;
-                // Custom Error Enhancements (replicating Zod logic)
-                // ArkType error for missing string might differ, typically says "must be a string"
-                if (path.endsWith("on") && (message.includes("string") || message.includes("must be"))) {
-                    // Heuristic check if it failed because it was interpretted as boolean 'true' in YAML
-                    // We can't see the original value easily here without checking 'data' at path
-                    // But we can just suggest it generally.
-                    if (typeof data === 'object' && data && data.on === true) {
-                        message = "The 'on' field is incorrect (boolean true found).";
-                        suggestion = "In YAML, 'on' is a boolean keyword (true). Quote it: \"on\": \"EventName\"";
-                    }
-                    else {
-                        // Generic suggestion
-                        suggestion = "Ensure 'on' is a string event name.";
-                    }
-                }
-                issues.push({
-                    path,
-                    message,
-                    suggestion,
-                    severity: "error"
-                });
-            }
-            return { valid: false, issues };
-        }
-        // Structural validation passed. Now perform Semantic Validation (Value Types)
-        const rule = out;
-        const semanticIssues = [];
-        this.validateConditionsRecursive(rule.if, semanticIssues, 'if');
-        if (semanticIssues.length > 0) {
-            return { valid: false, issues: semanticIssues };
-        }
-        return { valid: true, rule };
-    }
-    static validateConditionsRecursive(condition, issues, path) {
-        if (!condition)
-            return;
-        if (Array.isArray(condition)) {
-            condition.forEach((c, idx) => {
-                this.validateConditionsRecursive(c, issues, `${path}.${idx}`);
-            });
-            return;
-        }
-        // Check if it's a ConditionGroup (has 'conditions')
-        if ('conditions' in condition && Array.isArray(condition.conditions)) {
-            condition.conditions.forEach((c, idx) => {
-                this.validateConditionsRecursive(c, issues, `${path}.conditions.${idx}`);
-            });
-            return;
-        }
-        // It must be a Condition
-        if ('operator' in condition && 'value' in condition) {
-            this.validateConditionValue(condition, issues, path);
-        }
-    }
-    static validateConditionValue(condition, issues, path) {
-        const { operator, value } = condition;
-        // 1. List/Collection Operators (IN, NOT_IN, RANGE, CONTAINS)
-        if (['IN', 'NOT_IN', 'RANGE', 'CONTAINS'].includes(operator)) {
-            if (operator === 'CONTAINS') {
-                if (typeof value !== 'string' && !Array.isArray(value)) {
-                    issues.push({
-                        path: `${path}.value`,
-                        message: `Incorrect value type: Operator 'CONTAINS' expects a String or List (Array), but received ${typeof value}.`,
-                        suggestion: "Use a substring or a list of items.",
-                        severity: "error"
-                    });
-                }
-                return;
-            }
-            if (!Array.isArray(value)) {
-                issues.push({
-                    path: `${path}.value`,
-                    message: `Incorrect value type: Operator '${operator}' expects a List (Array), but received ${typeof value}.`,
-                    suggestion: operator === 'RANGE' ? "Use format [min, max]" : "Use format [item1, item2]",
-                    severity: "error"
-                });
-                return;
-            }
-            if (operator === 'RANGE') {
-                if (value.length !== 2) {
-                    issues.push({
-                        path: `${path}.value`,
-                        message: `Invalid Range: Operator 'RANGE' requires exactly 2 values (min and max).`,
-                        suggestion: "Use format [min, max], e.g. [1, 10]",
-                        severity: "error"
-                    });
-                }
-                else if (typeof value[0] !== 'number' && typeof value[0] !== 'string') {
-                    issues.push({
-                        path: `${path}.value`,
-                        message: `Incorrect range type: Range values must be numbers or expression strings.`,
-                        severity: "error"
-                    });
-                }
-            }
-        }
-        // 2. Regex
-        else if (operator === 'MATCHES') {
-            if (typeof value !== 'string') {
-                issues.push({
-                    path: `${path}.value`,
-                    message: `Incorrect value type: Operator 'MATCHES' expects a string (regex pattern), but received ${typeof value}.`,
-                    severity: "error"
-                });
-            }
-            else {
-                try {
-                    new RegExp(value);
-                }
-                catch (e) {
-                    issues.push({
-                        path: `${path}.value`,
-                        message: `Invalid Regex pattern: ${e.message}`,
-                        severity: "error"
-                    });
-                }
-            }
-        }
-        // 3. Numeric Comparisons (GT, LT, etc)
-        else if (['GT', 'GTE', 'LT', 'LTE', '>', '>=', '<', '<='].includes(operator)) {
-            if (typeof value !== 'number' && typeof value !== 'string') {
-                issues.push({
-                    path: `${path}.value`,
-                    message: `Incorrect value type: Operator '${operator}' expects a number or expression string, but received ${typeof value}.`,
-                    severity: "error"
-                });
-            }
-        }
-    }
-}
-exports.TriggerValidator = TriggerValidator;
-//# sourceMappingURL=validator.js.map

package/dist/lsp/domain/validator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"validator.js","sourceRoot":"","sources":["../../../src/domain/validator.ts"],"names":[],"mappings":"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"}

package/dist/lsp/hover.d.ts

@@ -1,7 +0,0 @@
-import type { Hover, Position } from 'vscode-languageserver/node';
-import type { TextDocument } from 'vscode-languageserver-textdocument';
-/**
- * Get hover information for a position in the document
- */
-export declare function getHover(document: TextDocument, position: Position): Hover | null;
-//# sourceMappingURL=hover.d.ts.map

package/dist/lsp/hover.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hover.d.ts","sourceRoot":"","sources":["../../src/lsp/hover.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAiB,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AACjF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAiPvE;;GAEG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,YAAY,EAAE,QAAQ,EAAE,QAAQ,GAAG,KAAK,GAAG,IAAI,CAyHjF"}