@sayue_ltr/fleq 1.50.0 → 1.51.0

package/dist/engine/filter/parser.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = parse;
+const errors_1 = require("./errors");
+const MAX_DEPTH = 32;
+class Parser {
+    tokens;
+    source;
+    pos = 0;
+    depth = 0;
+    constructor(tokens, source) {
+        this.tokens = tokens;
+        this.source = source;
+    }
+    parse() {
+        const ast = this.parseOr();
+        if (this.current().kind !== "eof") {
+            throw new errors_1.FilterSyntaxError(this.source, this.current().pos, "で予期しないトークン");
+        }
+        return ast;
+    }
+    parseOr() {
+        const children = [this.parseAnd()];
+        while (this.current().kind === "or") {
+            this.advance();
+            children.push(this.parseAnd());
+        }
+        return children.length === 1 ? children[0] : { kind: "or", children };
+    }
+    parseAnd() {
+        const children = [this.parseUnary()];
+        while (this.current().kind === "and") {
+            this.advance();
+            children.push(this.parseUnary());
+        }
+        return children.length === 1 ? children[0] : { kind: "and", children };
+    }
+    parseUnary() {
+        if (this.current().kind === "not") {
+            this.advance();
+            this.enterDepth();
+            const operand = this.parseUnary();
+            this.leaveDepth();
+            return { kind: "not", operand };
+        }
+        return this.parsePrimary();
+    }
+    parsePrimary() {
+        if (this.current().kind === "lparen") {
+            this.advance();
+            this.enterDepth();
+            const expr = this.parseOr();
+            this.leaveDepth();
+            this.expect("rparen", "で閉じ括弧 ')' が必要");
+            return expr;
+        }
+        const left = this.parseValue();
+        const op = this.tryCompOp();
+        if (op == null) {
+            return { kind: "truthy", value: left };
+        }
+        const right = this.parseValue();
+        return { kind: "comparison", left, op, right };
+    }
+    parseValue() {
+        const token = this.current();
+        switch (token.kind) {
+            case "ident":
+                this.advance();
+                return { kind: "path", segments: token.value.split("."), pos: token.pos };
+            case "string":
+                this.advance();
+                return { kind: "string", value: token.value, pos: token.pos };
+            case "number":
+                this.advance();
+                return { kind: "number", value: Number(token.value), pos: token.pos };
+            case "boolean":
+                this.advance();
+                return { kind: "boolean", value: token.value === "true", pos: token.pos };
+            case "null":
+                this.advance();
+                return { kind: "null", pos: token.pos };
+            case "lbracket":
+                return this.parseList();
+            default:
+                throw new errors_1.FilterSyntaxError(this.source, token.pos, "で値が必要");
+        }
+    }
+    parseList() {
+        const start = this.current().pos;
+        this.expect("lbracket", "で '[' が必要");
+        const items = [];
+        while (this.current().kind !== "rbracket") {
+            if (items.length > 0) {
+                this.expect("comma", "で ',' が必要");
+            }
+            items.push(this.parseValue());
+        }
+        this.expect("rbracket", "で ']' が必要");
+        return { kind: "list", items, pos: start };
+    }
+    tryCompOp() {
+        const token = this.current();
+        if (token.kind === "op") {
+            this.advance();
+            return token.value;
+        }
+        return null;
+    }
+    current() {
+        return this.tokens[this.pos];
+    }
+    advance() {
+        const token = this.tokens[this.pos];
+        if (this.pos < this.tokens.length - 1)
+            this.pos++;
+        return token;
+    }
+    expect(kind, errorMsg) {
+        if (this.current().kind !== kind) {
+            throw new errors_1.FilterSyntaxError(this.source, this.current().pos, errorMsg);
+        }
+        this.advance();
+    }
+    enterDepth() {
+        this.depth++;
+        if (this.depth > MAX_DEPTH) {
+            throw new errors_1.FilterSyntaxError(this.source, this.current().pos, `でネストが深すぎる (最大 ${MAX_DEPTH} 段)`);
+        }
+    }
+    leaveDepth() {
+        this.depth--;
+    }
+}
+function parse(tokens, source) {
+    return new Parser(tokens, source).parse();
+}

package/dist/engine/filter/rank-maps.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LG_INT_RANK = exports.INTENSITY_RANK = exports.FRAME_LEVEL_RANK = void 0;
+exports.toFrameLevelRank = toFrameLevelRank;
+exports.toIntensityRank = toIntensityRank;
+exports.toLgIntRank = toLgIntRank;
+/** frameLevel → 数値ランク (順序比較用) */
+exports.FRAME_LEVEL_RANK = {
+    cancel: 0,
+    info: 1,
+    normal: 2,
+    warning: 3,
+    critical: 4,
+};
+/** 震度文字列 → 数値ランク (順序比較用) */
+exports.INTENSITY_RANK = {
+    "1": 1, "2": 2, "3": 3, "4": 4,
+    "5-": 5, "5弱": 5, "5+": 6, "5強": 6,
+    "6-": 7, "6弱": 7, "6+": 8, "6強": 8, "7": 9,
+};
+/** 長周期地震動階級 → 数値ランク */
+exports.LG_INT_RANK = {
+    "0": 0, "1": 1, "2": 2, "3": 3, "4": 4,
+};
+/** 文字列からランク値を返す。未知の値は null */
+function toFrameLevelRank(value) {
+    return exports.FRAME_LEVEL_RANK[value] ?? null;
+}
+function toIntensityRank(value) {
+    return exports.INTENSITY_RANK[value.replace(/\s+/g, "")] ?? null;
+}
+function toLgIntRank(value) {
+    return exports.LG_INT_RANK[value] ?? null;
+}

package/dist/engine/filter/tokenizer.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tokenize = tokenize;
+const errors_1 = require("./errors");
+const KEYWORDS = {
+    and: "and",
+    or: "or",
+    not: "not",
+    true: "boolean",
+    false: "boolean",
+    null: "null",
+    in: "op",
+    contains: "op",
+};
+const OPERATORS = ["!=", "<=", ">=", "!~", "=", "<", ">", "~"];
+function tokenize(source) {
+    const tokens = [];
+    let i = 0;
+    while (i < source.length) {
+        // 空白スキップ
+        if (/\s/.test(source[i])) {
+            i++;
+            continue;
+        }
+        // 文字列リテラル
+        if (source[i] === '"' || source[i] === "'") {
+            const quote = source[i];
+            const start = i;
+            i++; // 開き引用符
+            let value = "";
+            while (i < source.length && source[i] !== quote) {
+                if (source[i] === "\\" && i + 1 < source.length) {
+                    i++;
+                    value += source[i];
+                }
+                else {
+                    value += source[i];
+                }
+                i++;
+            }
+            if (i >= source.length) {
+                throw new errors_1.FilterSyntaxError(source, start, "で文字列が閉じられていない");
+            }
+            i++; // 閉じ引用符
+            tokens.push({ kind: "string", value, pos: start });
+            continue;
+        }
+        // 数値リテラル
+        if (/[0-9]/.test(source[i]) || (source[i] === "-" && i + 1 < source.length && /[0-9]/.test(source[i + 1]))) {
+            const start = i;
+            if (source[i] === "-")
+                i++;
+            while (i < source.length && /[0-9]/.test(source[i]))
+                i++;
+            if (i < source.length && source[i] === ".") {
+                i++;
+                while (i < source.length && /[0-9]/.test(source[i]))
+                    i++;
+            }
+            tokens.push({ kind: "number", value: source.slice(start, i), pos: start });
+            continue;
+        }
+        // 括弧・ブラケット・カンマ
+        if (source[i] === "(") {
+            tokens.push({ kind: "lparen", value: "(", pos: i });
+            i++;
+            continue;
+        }
+        if (source[i] === ")") {
+            tokens.push({ kind: "rparen", value: ")", pos: i });
+            i++;
+            continue;
+        }
+        if (source[i] === "[") {
+            tokens.push({ kind: "lbracket", value: "[", pos: i });
+            i++;
+            continue;
+        }
+        if (source[i] === "]") {
+            tokens.push({ kind: "rbracket", value: "]", pos: i });
+            i++;
+            continue;
+        }
+        if (source[i] === ",") {
+            tokens.push({ kind: "comma", value: ",", pos: i });
+            i++;
+            continue;
+        }
+        // 演算子
+        let matchedOp = null;
+        for (const op of OPERATORS) {
+            if (source.startsWith(op, i)) {
+                matchedOp = op;
+                break;
+            }
+        }
+        if (matchedOp != null) {
+            tokens.push({ kind: "op", value: matchedOp, pos: i });
+            i += matchedOp.length;
+            continue;
+        }
+        // 識別子 / キーワード (dot パス含む)
+        if (/[a-zA-Z_]/.test(source[i])) {
+            const start = i;
+            while (i < source.length && /[a-zA-Z0-9_.]/.test(source[i]))
+                i++;
+            const word = source.slice(start, i);
+            const keyword = KEYWORDS[word];
+            if (keyword != null) {
+                tokens.push({ kind: keyword, value: word, pos: start });
+            }
+            else {
+                tokens.push({ kind: "ident", value: word, pos: start });
+            }
+            continue;
+        }
+        throw new errors_1.FilterSyntaxError(source, i, `で予期しない文字 '${source[i]}'`);
+    }
+    tokens.push({ kind: "eof", value: "", pos: source.length });
+    return tokens;
+}

package/dist/engine/filter/type-checker.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typeCheck = typeCheck;
+const field_registry_1 = require("./field-registry");
+const errors_1 = require("./errors");
+/** AST を走査し、フィールド参照と演算子の型整合を検証する */
+function typeCheck(ast, source) {
+    switch (ast.kind) {
+        case "or":
+        case "and":
+            for (const child of ast.children)
+                typeCheck(child, source);
+            break;
+        case "not":
+            typeCheck(ast.operand, source);
+            break;
+        case "truthy":
+            validateFieldExists(ast.value);
+            break;
+        case "comparison":
+            validateComparison(ast.left, ast.op, ast.right, source);
+            break;
+    }
+}
+function validateFieldExists(node) {
+    if (node.kind === "path") {
+        const name = node.segments.join(".");
+        const field = (0, field_registry_1.resolveField)(name);
+        if (field == null) {
+            throw new errors_1.FilterFieldError(name, (0, field_registry_1.fieldNames)());
+        }
+    }
+}
+function validateComparison(left, op, right, source) {
+    // パスが左辺にある場合のフィールド検証
+    if (left.kind === "path") {
+        const name = left.segments.join(".");
+        const field = (0, field_registry_1.resolveField)(name);
+        if (field == null) {
+            throw new errors_1.FilterFieldError(name, (0, field_registry_1.fieldNames)());
+        }
+        // enum 型に対する数値リテラルチェック
+        if (field.kind === "enum:intensity" && right.kind === "number") {
+            throw new errors_1.FilterTypeError(`型が不一致: ${name} ${op} ${right.value}\n` +
+                `\`${name}\` は震度文字列("1", "5-", "6+"等)で比較する。数値リテラルは使えない`);
+        }
+        if (field.kind === "enum:lgInt" && right.kind === "number") {
+            throw new errors_1.FilterTypeError(`型が不一致: ${name} ${op} ${right.value}\n` +
+                `\`${name}\` は長周期階級文字列("0"〜"4")で比較する。数値リテラルは使えない`);
+        }
+        // 順序比較の型検証
+        if (op === "<" || op === "<=" || op === ">" || op === ">=") {
+            if (!field.supportsOrder) {
+                throw new errors_1.FilterTypeError(`\`${name}\` (${field.kind}) は順序比較に対応していない`);
+            }
+        }
+        // regex 演算子の検証
+        if (op === "~" || op === "!~") {
+            if (field.kind !== "string" && field.kind !== "enum:frameLevel" && field.kind !== "enum:intensity" && field.kind !== "enum:lgInt") {
+                throw new errors_1.FilterTypeError(`\`${name}\` (${field.kind}) は正規表現マッチに対応していない`);
+            }
+            if (right.kind === "string") {
+                try {
+                    new RegExp(right.value);
+                }
+                catch {
+                    throw new errors_1.FilterTypeError(`正規表現が不正だ: "~" の右辺 "${right.value}" を解釈できない`);
+                }
+                if (isRedosRisk(right.value)) {
+                    throw new errors_1.FilterTypeError(`正規表現が危険だ: "${right.value}" は入れ子の量指定子を含んでおり、ReDoS の恐れがある`);
+                }
+            }
+        }
+        // in の検証: 右辺はリストでなければならない
+        if (op === "in") {
+            if (right.kind !== "list") {
+                throw new errors_1.FilterTypeError(`\`in\` の右辺にはリスト [...] が必要`);
+            }
+        }
+        // contains の検証
+        if (op === "contains") {
+            if (field.kind !== "string[]" && field.kind !== "number[]" && field.kind !== "string") {
+                throw new errors_1.FilterTypeError(`\`${name}\` (${field.kind}) は contains に対応していない`);
+            }
+            // 右辺はリテラル (string/number) でなければならない
+            if (right.kind !== "string" && right.kind !== "number") {
+                throw new errors_1.FilterTypeError(`\`contains\` の右辺にはリテラル (文字列または数値) が必要`);
+            }
+        }
+    }
+    // 右辺のパスも検証
+    if (right.kind === "path") {
+        validateFieldExists(right);
+    }
+}
+/**
+ * 入れ子の量指定子パターンを簡易検出して ReDoS リスクを判定する。
+ * `(a+)+`, `(a*)*`, `(a+)*` のように、量指定子を含むグループに
+ * さらに量指定子が付くケースを検出する。
+ */
+function isRedosRisk(pattern) {
+    // 量指定子(+, *, ?, {n,m})で終わるグループの直後に量指定子が来るパターン
+    return /(\+|\*|\?|\})\)(\+|\*|\?|\{)/.test(pattern);
+}

package/dist/engine/filter/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/engine/filter-template/pipeline-controller.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PipelineController = void 0;
+const compile_filter_1 = require("../filter/compile-filter");
+const compile_template_1 = require("../template/compile-template");
+/**
+ * FilterTemplatePipeline の状態を管理する controller。
+ * REPL はこの API 経由でのみ pipeline を変更する。
+ * getPipeline() は同一オブジェクト参照を返すため、
+ * message-router 側に渡した pipeline と常に同期する。
+ */
+class PipelineController {
+    _pipeline;
+    _filterExpr = null;
+    _templateExpr = null;
+    _focusExpr = null;
+    constructor() {
+        this._pipeline = { filter: null, template: null, focus: null };
+    }
+    /** 同一オブジェクト参照を返す。router 側と共有される。 */
+    getPipeline() {
+        return this._pipeline;
+    }
+    // --- Filter ---
+    getFilterExpr() { return this._filterExpr; }
+    /** フィルタ式をコンパイルして設定する。無効な式の場合は例外を投げる。 */
+    setFilter(expr) {
+        const predicate = (0, compile_filter_1.compileFilter)(expr);
+        this._pipeline.filter = predicate;
+        this._filterExpr = expr;
+    }
+    clearFilter() {
+        this._pipeline.filter = null;
+        this._filterExpr = null;
+    }
+    // --- Template ---
+    getTemplateExpr() { return this._templateExpr; }
+    /** テンプレート式をコンパイルして設定する。 */
+    setTemplate(expr) {
+        const renderer = (0, compile_template_1.compileTemplate)(expr);
+        this._pipeline.template = renderer;
+        this._templateExpr = expr;
+    }
+    clearTemplate() {
+        this._pipeline.template = null;
+        this._templateExpr = null;
+    }
+    // --- Focus ---
+    getFocusExpr() { return this._focusExpr; }
+    /** フォーカス式をコンパイルして設定する。無効な式の場合は例外を投げる。 */
+    setFocus(expr) {
+        const predicate = (0, compile_filter_1.compileFilter)(expr);
+        this._pipeline.focus = predicate;
+        this._focusExpr = expr;
+    }
+    clearFocus() {
+        this._pipeline.focus = null;
+        this._focusExpr = null;
+    }
+    // --- Factory ---
+    /** 式文字列から PipelineController を構築する。null/undefined はスキップ。 */
+    static fromExpressions(opts) {
+        const ctrl = new PipelineController();
+        if (opts.filter != null)
+            ctrl.setFilter(opts.filter);
+        if (opts.template != null)
+            ctrl.setTemplate(opts.template);
+        if (opts.focus != null)
+            ctrl.setFocus(opts.focus);
+        return ctrl;
+    }
+}
+exports.PipelineController = PipelineController;

package/dist/engine/filter-template/pipeline.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldDisplay = shouldDisplay;
+exports.renderTemplate = renderTemplate;
+/** PresentationEvent にフィルタを適用する。true = 表示、false = 非表示 */
+function shouldDisplay(event, pipeline) {
+    if (pipeline.filter == null)
+        return true;
+    return pipeline.filter(event);
+}
+/** テンプレートが設定されていれば1行に変換する。null = テンプレートなし */
+function renderTemplate(event, pipeline) {
+    if (pipeline.template == null)
+        return null;
+    return pipeline.template(event);
+}

package/dist/engine/messages/display-callbacks.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * engine → ui の逆方向依存を解消するための表示コールバックインターフェース。
+ * engine 層はこのインターフェースを通じてのみ表示を行う。
+ * 実装は ui 層の display-adapter.ts で提供される。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });