@sayue_ltr/fleq 1.50.1 → 2.0.0

package/dist/engine/filter/compiler.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compile = compile;
+const field_registry_1 = require("./field-registry");
+const rank_maps_1 = require("./rank-maps");
+function compile(ast) {
+    switch (ast.kind) {
+        case "or":
+            return compileOr(ast.children.map(compile));
+        case "and":
+            return compileAnd(ast.children.map(compile));
+        case "not":
+            return compileNot(compile(ast.operand));
+        case "truthy":
+            return compileTruthy(ast.value);
+        case "comparison":
+            return compileComparison(ast.left, ast.op, ast.right);
+    }
+}
+function compileOr(predicates) {
+    return (event) => predicates.some((p) => p(event));
+}
+function compileAnd(predicates) {
+    return (event) => predicates.every((p) => p(event));
+}
+function compileNot(predicate) {
+    return (event) => !predicate(event);
+}
+function compileTruthy(node) {
+    const getter = makeGetter(node);
+    return (event) => {
+        const val = getter(event);
+        return val != null && val !== false && val !== "" && val !== 0;
+    };
+}
+function compileComparison(left, op, right) {
+    const getLeft = makeGetter(left);
+    const getRight = makeGetter(right);
+    // フィールドの型情報を取得 (enum ランク変換用)
+    const leftField = left.kind === "path" ? (0, field_registry_1.resolveField)(left.segments.join(".")) : null;
+    const rankFn = leftField ? getRankFn(leftField.kind) : null;
+    switch (op) {
+        case "=":
+            return (event) => {
+                const l = getLeft(event);
+                const r = getRight(event);
+                if (l == null || r == null)
+                    return false;
+                return l === r;
+            };
+        case "!=":
+            return (event) => {
+                const l = getLeft(event);
+                const r = getRight(event);
+                if (l == null || r == null)
+                    return false;
+                return l !== r;
+            };
+        case "<":
+        case "<=":
+        case ">":
+        case ">=":
+            return (event) => {
+                let l = getLeft(event);
+                let r = getRight(event);
+                if (l == null || r == null)
+                    return false;
+                if (rankFn != null) {
+                    l = rankFn(String(l));
+                    r = rankFn(String(r));
+                    if (l == null || r == null)
+                        return false;
+                }
+                return compareOrdered(l, op, r);
+            };
+        case "~": {
+            // 右辺が文字列リテラルならコンパイル時に RegExp をキャッシュ
+            const cachedRegex = right.kind === "string" ? new RegExp(right.value) : null;
+            return (event) => {
+                const l = getLeft(event);
+                if (l == null)
+                    return false;
+                const re = cachedRegex ?? (() => {
+                    const r = getRight(event);
+                    if (r == null)
+                        return null;
+                    try {
+                        return new RegExp(String(r));
+                    }
+                    catch {
+                        return null;
+                    }
+                })();
+                if (re == null)
+                    return false;
+                return re.test(String(l));
+            };
+        }
+        case "!~": {
+            const cachedRegexNeg = right.kind === "string" ? new RegExp(right.value) : null;
+            return (event) => {
+                const l = getLeft(event);
+                if (l == null)
+                    return false;
+                const re = cachedRegexNeg ?? (() => {
+                    const r = getRight(event);
+                    if (r == null)
+                        return null;
+                    try {
+                        return new RegExp(String(r));
+                    }
+                    catch {
+                        return null;
+                    }
+                })();
+                if (re == null)
+                    return false;
+                return !re.test(String(l));
+            };
+        }
+        case "in":
+            return (event) => {
+                const l = getLeft(event);
+                const r = getRight(event);
+                if (l == null || r == null)
+                    return false;
+                if (Array.isArray(r))
+                    return r.includes(l);
+                return false;
+            };
+        case "contains":
+            return (event) => {
+                const l = getLeft(event);
+                const r = getRight(event);
+                if (l == null || r == null)
+                    return false;
+                if (Array.isArray(l))
+                    return l.includes(r);
+                if (typeof l === "string" && typeof r === "string")
+                    return l.includes(r);
+                return false;
+            };
+    }
+}
+function makeGetter(node) {
+    switch (node.kind) {
+        case "path": {
+            const field = (0, field_registry_1.resolveField)(node.segments.join("."));
+            if (field == null)
+                return () => null;
+            return (event) => field.get(event);
+        }
+        case "string":
+            return () => node.value;
+        case "number":
+            return () => node.value;
+        case "boolean":
+            return () => node.value;
+        case "null":
+            return () => null;
+        case "list":
+            return () => node.items.map((item) => {
+                switch (item.kind) {
+                    case "string": return item.value;
+                    case "number": return item.value;
+                    case "boolean": return item.value;
+                    default: return null;
+                }
+            });
+    }
+}
+function compareOrdered(l, op, r) {
+    switch (op) {
+        case "<": return l < r;
+        case "<=": return l <= r;
+        case ">": return l > r;
+        case ">=": return l >= r;
+        default: return false;
+    }
+}
+function getRankFn(kind) {
+    switch (kind) {
+        case "enum:frameLevel": return rank_maps_1.toFrameLevelRank;
+        case "enum:intensity": return rank_maps_1.toIntensityRank;
+        case "enum:lgInt": return rank_maps_1.toLgIntRank;
+        default: return null;
+    }
+}

package/dist/engine/filter/errors.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterFieldError = exports.FilterTypeError = exports.FilterSyntaxError = void 0;
+class FilterSyntaxError extends Error {
+    source;
+    position;
+    constructor(source, position, message) {
+        super(message);
+        this.source = source;
+        this.position = position;
+        this.name = "FilterSyntaxError";
+    }
+    /** 位置付きフォーマット済みエラー表示 */
+    format() {
+        const pointer = " ".repeat(this.position) + "^";
+        return `フィルタ構文エラー: ${this.position + 1}文字目${this.message}\n${this.source}\n${pointer}`;
+    }
+}
+exports.FilterSyntaxError = FilterSyntaxError;
+class FilterTypeError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "FilterTypeError";
+    }
+}
+exports.FilterTypeError = FilterTypeError;
+class FilterFieldError extends Error {
+    fieldName;
+    availableFields;
+    constructor(fieldName, availableFields) {
+        super(`未知のフィールド: ${fieldName}`);
+        this.fieldName = fieldName;
+        this.availableFields = availableFields;
+        this.name = "FilterFieldError";
+    }
+    format() {
+        const examples = this.availableFields.slice(0, 6).join(", ");
+        return `未知のフィールド: ${this.fieldName}\n使える例: ${examples}`;
+    }
+}
+exports.FilterFieldError = FilterFieldError;

package/dist/engine/filter/field-registry.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FILTER_FIELDS = void 0;
+exports.resolveField = resolveField;
+exports.fieldNames = fieldNames;
+function field(kind, aliases, get, supportsOrder) {
+    return { kind, aliases, get, supportsOrder };
+}
+/** depth 文字列 "10km" → 数値 10 */
+function parseDepth(d) {
+    if (d == null)
+        return null;
+    const m = d.match(/^(\d+)/);
+    return m ? Number(m[1]) : null;
+}
+/** magnitude 文字列 → 数値 */
+function parseMagnitude(m) {
+    if (m == null)
+        return null;
+    const n = Number(m);
+    return Number.isFinite(n) ? n : null;
+}
+exports.FILTER_FIELDS = {
+    // 識別
+    domain: field("string", [], (e) => e.domain),
+    type: field("string", ["headType"], (e) => e.type),
+    subType: field("string", [], (e) => e.subType),
+    classification: field("string", [], (e) => e.classification),
+    id: field("string", [], (e) => e.id),
+    infoType: field("string", [], (e) => e.infoType),
+    // レベル
+    frameLevel: field("enum:frameLevel", ["level"], (e) => e.frameLevel, true),
+    // 状態フラグ
+    isCancellation: field("boolean", ["isCancelled"], (e) => e.isCancellation),
+    isWarning: field("boolean", [], (e) => e.isWarning),
+    isFinal: field("boolean", [], (e) => e.isFinal),
+    isTest: field("boolean", [], (e) => e.isTest),
+    isRenotification: field("boolean", [], (e) => e.isRenotification),
+    // イベント追跡
+    eventId: field("string", [], (e) => e.eventId),
+    serial: field("string", [], (e) => e.serial),
+    volcanoCode: field("string", [], (e) => e.volcanoCode),
+    volcanoName: field("string", [], (e) => e.volcanoName),
+    // 震源情報
+    hypocenterName: field("string", ["hypocenter"], (e) => e.hypocenterName),
+    depth: field("number", [], (e) => parseDepth(e.depth), true),
+    magnitude: field("number", ["mag"], (e) => parseMagnitude(e.magnitude), true),
+    // 強度
+    maxInt: field("enum:intensity", [], (e) => e.maxInt, true),
+    maxLgInt: field("enum:lgInt", [], (e) => e.maxLgInt, true),
+    forecastMaxInt: field("enum:intensity", [], (e) => e.forecastMaxInt, true),
+    alertLevel: field("number", [], (e) => e.alertLevel, true),
+    // テキスト
+    title: field("string", [], (e) => e.title),
+    headline: field("string", [], (e) => e.headline),
+    // 地域集約
+    areaNames: field("string[]", [], (e) => e.areaNames),
+    forecastAreaNames: field("string[]", [], (e) => e.forecastAreaNames),
+    municipalityNames: field("string[]", [], (e) => e.municipalityNames),
+    observationNames: field("string[]", [], (e) => e.observationNames),
+    areaCount: field("number", [], (e) => e.areaCount),
+    // 津波
+    tsunamiKinds: field("string[]", [], (e) => e.tsunamiKinds),
+};
+/** フィールド名 or エイリアスから FilterField を解決する */
+function resolveField(name) {
+    if (name in exports.FILTER_FIELDS)
+        return exports.FILTER_FIELDS[name];
+    for (const [, f] of Object.entries(exports.FILTER_FIELDS)) {
+        if (f.aliases.includes(name))
+            return f;
+    }
+    return null;
+}
+/** 公開フィールド名一覧 (エラーメッセージ用) */
+function fieldNames() {
+    return Object.keys(exports.FILTER_FIELDS);
+}

package/dist/engine/filter/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fieldNames = exports.resolveField = exports.FilterFieldError = exports.FilterTypeError = exports.FilterSyntaxError = exports.compileFilter = void 0;
+// 公開 API
+var compile_filter_1 = require("./compile-filter");
+Object.defineProperty(exports, "compileFilter", { enumerable: true, get: function () { return compile_filter_1.compileFilter; } });
+// エラー
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "FilterSyntaxError", { enumerable: true, get: function () { return errors_1.FilterSyntaxError; } });
+Object.defineProperty(exports, "FilterTypeError", { enumerable: true, get: function () { return errors_1.FilterTypeError; } });
+Object.defineProperty(exports, "FilterFieldError", { enumerable: true, get: function () { return errors_1.FilterFieldError; } });
+// フィールドユーティリティ
+var field_registry_1 = require("./field-registry");
+Object.defineProperty(exports, "resolveField", { enumerable: true, get: function () { return field_registry_1.resolveField; } });
+Object.defineProperty(exports, "fieldNames", { enumerable: true, get: function () { return field_registry_1.fieldNames; } });

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;
+}