@zwave-js/config 15.15.3 → 15.16.0

package/build/cjs/Logic.d.ts

@@ -1,4 +1,4 @@
 import { type RulesLogic } from "json-logic-js";
-export declare function parseLogic(logic: string): RulesLogic;
+export declare function parseLogic(input: string): RulesLogic;
 export declare function evaluate(logic: string, context: unknown): string | number | boolean;
 //# sourceMappingURL=Logic.d.ts.map

package/build/cjs/Logic.js

@@ -39,8 +39,8 @@ var import_gt = __toESM(require("semver/functions/gt.js"), 1);
 var import_gte = __toESM(require("semver/functions/gte.js"), 1);
 var import_lt = __toESM(require("semver/functions/lt.js"), 1);
 var import_lte = __toESM(require("semver/functions/lte.js"), 1);
-var import_LogicParser = require("./LogicParser.js");
 var import_json_logic_js = __toESM(require("json-logic-js"), 1);
+var import_LogicParser = require("./LogicParser.js");
 const { add_operation, apply } = import_json_logic_js.default;
 function tryOr(operation, onError) {
   return ((...args) => {
@@ -57,13 +57,12 @@ add_operation("ver >", tryOr((a, b) => (0, import_gt.default)((0, import_shared.
 add_operation("ver <=", tryOr((a, b) => (0, import_lte.default)((0, import_shared.padVersion)(a), (0, import_shared.padVersion)(b)), false));
 add_operation("ver <", tryOr((a, b) => (0, import_lt.default)((0, import_shared.padVersion)(a), (0, import_shared.padVersion)(b)), false));
 add_operation("ver ===", tryOr((a, b) => (0, import_eq.default)((0, import_shared.padVersion)(a), (0, import_shared.padVersion)(b)), false));
-function parseLogic(logic) {
-  try {
-    return (0, import_LogicParser.parse)(logic);
-  } catch (e) {
-    throw new Error(`Invalid logic: ${logic}
-${e.message}`);
+function parseLogic(input) {
+  const expr = (0, import_LogicParser.parse)(input);
+  if (!expr) {
+    throw new Error(`Failed to parse expression: ${input}`);
   }
+  return (0, import_LogicParser.toRulesLogic)(expr);
 }
 __name(parseLogic, "parseLogic");
 function evaluate(logic, context) {

package/build/cjs/Logic.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/Logic.ts"],
-  "sourcesContent": ["import { padVersion } from \"@zwave-js/shared\";\nimport semverEq from \"semver/functions/eq.js\";\nimport semverGt from \"semver/functions/gt.js\";\nimport semverGte from \"semver/functions/gte.js\";\nimport semverLt from \"semver/functions/lt.js\";\nimport semverLte from \"semver/functions/lte.js\";\nimport { parse } from \"./LogicParser.js\";\n\n// The types are not correct:\nimport { type RulesLogic, default as JsonLogic } from \"json-logic-js\";\nconst { add_operation, apply } = JsonLogic;\n\nfunction tryOr<T extends (...args: any[]) => any>(\n\toperation: T,\n\tonError: ReturnType<T>,\n): T {\n\treturn ((...args: any[]) => {\n\t\ttry {\n\t\t\treturn operation(...args);\n\t\t} catch {\n\t\t\treturn onError;\n\t\t}\n\t}) as any as T;\n}\n\nadd_operation(\n\t\"ver >=\",\n\ttryOr((a, b) => semverGte(padVersion(a), padVersion(b)), false),\n);\nadd_operation(\n\t\"ver >\",\n\ttryOr((a, b) => semverGt(padVersion(a), padVersion(b)), false),\n);\nadd_operation(\n\t\"ver <=\",\n\ttryOr((a, b) => semverLte(padVersion(a), padVersion(b)), false),\n);\nadd_operation(\n\t\"ver <\",\n\ttryOr((a, b) => semverLt(padVersion(a), padVersion(b)), false),\n);\nadd_operation(\n\t\"ver ===\",\n\ttryOr((a, b) => semverEq(padVersion(a), padVersion(b)), false),\n);\n\nexport function parseLogic(logic: string): RulesLogic {\n\ttry {\n\t\t// The generated types for the version comparisons are not compatible with the RulesLogic type\n\t\treturn parse(logic) as unknown as RulesLogic;\n\t} catch (e: any) {\n\t\tthrow new Error(`Invalid logic: ${logic}\\n${e.message}`);\n\t}\n}\n\nexport function evaluate(\n\tlogic: string,\n\tcontext: unknown,\n): string | number | boolean {\n\tconst rules = parseLogic(logic);\n\treturn apply(rules, context);\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;AAAA,oBAA2B;AAC3B,gBAAqB;AACrB,gBAAqB;AACrB,iBAAsB;AACtB,gBAAqB;AACrB,iBAAsB;AACtB,yBAAsB;AAGtB,2BAAsD;AACtD,MAAM,EAAE,eAAe,MAAK,IAAK,qBAAAA;AAEjC,SAAS,MACR,WACA,SAAsB;AAEtB,UAAQ,IAAI,SAAe;AAC1B,QAAI;AACH,aAAO,UAAU,GAAG,IAAI;IACzB,QAAQ;AACP,aAAO;IACR;EACD;AACD;AAXS;AAaT,cACC,UACA,MAAM,CAAC,GAAG,UAAM,WAAAC,aAAU,0BAAW,CAAC,OAAG,0BAAW,CAAC,CAAC,GAAG,KAAK,CAAC;AAEhE,cACC,SACA,MAAM,CAAC,GAAG,UAAM,UAAAC,aAAS,0BAAW,CAAC,OAAG,0BAAW,CAAC,CAAC,GAAG,KAAK,CAAC;AAE/D,cACC,UACA,MAAM,CAAC,GAAG,UAAM,WAAAC,aAAU,0BAAW,CAAC,OAAG,0BAAW,CAAC,CAAC,GAAG,KAAK,CAAC;AAEhE,cACC,SACA,MAAM,CAAC,GAAG,UAAM,UAAAC,aAAS,0BAAW,CAAC,OAAG,0BAAW,CAAC,CAAC,GAAG,KAAK,CAAC;AAE/D,cACC,WACA,MAAM,CAAC,GAAG,UAAM,UAAAC,aAAS,0BAAW,CAAC,OAAG,0BAAW,CAAC,CAAC,GAAG,KAAK,CAAC;AAGzD,SAAU,WAAW,OAAa;AACvC,MAAI;AAEH,eAAO,0BAAM,KAAK;EACnB,SAAS,GAAQ;AAChB,UAAM,IAAI,MAAM,kBAAkB,KAAK;EAAK,EAAE,OAAO,EAAE;EACxD;AACD;AAPgB;AASV,SAAU,SACf,OACA,SAAgB;AAEhB,QAAM,QAAQ,WAAW,KAAK;AAC9B,SAAO,MAAM,OAAO,OAAO;AAC5B;AANgB;",
+  "sourcesContent": ["import { padVersion } from \"@zwave-js/shared\";\nimport semverEq from \"semver/functions/eq.js\";\nimport semverGt from \"semver/functions/gt.js\";\nimport semverGte from \"semver/functions/gte.js\";\nimport semverLt from \"semver/functions/lt.js\";\nimport semverLte from \"semver/functions/lte.js\";\n\n// The types are not correct:\nimport { type RulesLogic, default as JsonLogic } from \"json-logic-js\";\nimport { parse, toRulesLogic } from \"./LogicParser.js\";\nconst { add_operation, apply } = JsonLogic;\n\nfunction tryOr<T extends (...args: any[]) => any>(\n\toperation: T,\n\tonError: ReturnType<T>,\n): T {\n\treturn ((...args: any[]) => {\n\t\ttry {\n\t\t\treturn operation(...args);\n\t\t} catch {\n\t\t\treturn onError;\n\t\t}\n\t}) as any as T;\n}\n\nadd_operation(\n\t\"ver >=\",\n\ttryOr((a, b) => semverGte(padVersion(a), padVersion(b)), false),\n);\nadd_operation(\n\t\"ver >\",\n\ttryOr((a, b) => semverGt(padVersion(a), padVersion(b)), false),\n);\nadd_operation(\n\t\"ver <=\",\n\ttryOr((a, b) => semverLte(padVersion(a), padVersion(b)), false),\n);\nadd_operation(\n\t\"ver <\",\n\ttryOr((a, b) => semverLt(padVersion(a), padVersion(b)), false),\n);\nadd_operation(\n\t\"ver ===\",\n\ttryOr((a, b) => semverEq(padVersion(a), padVersion(b)), false),\n);\n\nexport function parseLogic(input: string): RulesLogic {\n\tconst expr = parse(input);\n\tif (!expr) {\n\t\tthrow new Error(`Failed to parse expression: ${input}`);\n\t}\n\treturn toRulesLogic(expr);\n}\n\nexport function evaluate(\n\tlogic: string,\n\tcontext: unknown,\n): string | number | boolean {\n\tconst rules = parseLogic(logic);\n\treturn apply(rules, context);\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;AAAA,oBAA2B;AAC3B,gBAAqB;AACrB,gBAAqB;AACrB,iBAAsB;AACtB,gBAAqB;AACrB,iBAAsB;AAGtB,2BAAsD;AACtD,yBAAoC;AACpC,MAAM,EAAE,eAAe,MAAK,IAAK,qBAAAA;AAEjC,SAAS,MACR,WACA,SAAsB;AAEtB,UAAQ,IAAI,SAAe;AAC1B,QAAI;AACH,aAAO,UAAU,GAAG,IAAI;IACzB,QAAQ;AACP,aAAO;IACR;EACD;AACD;AAXS;AAaT,cACC,UACA,MAAM,CAAC,GAAG,UAAM,WAAAC,aAAU,0BAAW,CAAC,OAAG,0BAAW,CAAC,CAAC,GAAG,KAAK,CAAC;AAEhE,cACC,SACA,MAAM,CAAC,GAAG,UAAM,UAAAC,aAAS,0BAAW,CAAC,OAAG,0BAAW,CAAC,CAAC,GAAG,KAAK,CAAC;AAE/D,cACC,UACA,MAAM,CAAC,GAAG,UAAM,WAAAC,aAAU,0BAAW,CAAC,OAAG,0BAAW,CAAC,CAAC,GAAG,KAAK,CAAC;AAEhE,cACC,SACA,MAAM,CAAC,GAAG,UAAM,UAAAC,aAAS,0BAAW,CAAC,OAAG,0BAAW,CAAC,CAAC,GAAG,KAAK,CAAC;AAE/D,cACC,WACA,MAAM,CAAC,GAAG,UAAM,UAAAC,aAAS,0BAAW,CAAC,OAAG,0BAAW,CAAC,CAAC,GAAG,KAAK,CAAC;AAGzD,SAAU,WAAW,OAAa;AACvC,QAAM,WAAO,0BAAM,KAAK;AACxB,MAAI,CAAC,MAAM;AACV,UAAM,IAAI,MAAM,+BAA+B,KAAK,EAAE;EACvD;AACA,aAAO,iCAAa,IAAI;AACzB;AANgB;AAQV,SAAU,SACf,OACA,SAAgB;AAEhB,QAAM,QAAQ,WAAW,KAAK;AAC9B,SAAO,MAAM,OAAO,OAAO;AAC5B;AANgB;",
   "names": ["JsonLogic", "semverGte", "semverGt", "semverLte", "semverLt", "semverEq"]
 }

package/build/cjs/LogicParser.d.ts

@@ -1,93 +1,75 @@
-export interface FilePosition {
-    offset: number;
-    line: number;
-    column: number;
+import type { RulesLogic } from "json-logic-js";
+export declare enum SyntaxKind {
+    Group = 0,
+    Or = 1,
+    And = 2,
+    Comparison = 3,
+    Identifier = 4,
+    NumberLiteral = 5,
+    Version = 6
 }
-export interface FileRange {
-    start: FilePosition;
-    end: FilePosition;
-    source: string;
+export declare enum Operator {
+    Equal = 0,
+    NotEqual = 1,
+    LessThan = 2,
+    LessThanOrEqual = 3,
+    GreaterThan = 4,
+    GreaterThanOrEqual = 5
 }
-export interface LiteralExpectation {
-    type: "literal";
-    text: string;
-    ignoreCase: boolean;
-}
-export interface ClassParts extends Array<string | ClassParts> {
-}
-export interface ClassExpectation {
-    type: "class";
-    parts: ClassParts;
-    inverted: boolean;
-    ignoreCase: boolean;
-}
-export interface AnyExpectation {
-    type: "any";
-}
-export interface EndExpectation {
-    type: "end";
-}
-export interface OtherExpectation {
-    type: "other";
-    description: string;
-}
-export type Expectation = LiteralExpectation | ClassExpectation | AnyExpectation | EndExpectation | OtherExpectation;
-declare class _PeggySyntaxError extends Error {
-    static buildMessage(expected: Expectation[], found: string | null): string;
-    message: string;
-    expected: Expectation[];
-    found: string | null;
-    location: FileRange;
-    name: string;
-    constructor(message: string, expected: Expectation[], found: string | null, location: FileRange);
-    format(sources: {
-        source?: any;
-        text: string;
-    }[]): string;
-}
-export interface TraceEvent {
-    type: string;
-    rule: string;
-    result?: any;
-    location: FileRange;
-}
-export interface ParseOptions {
-    filename?: string;
-    startRule?: "start";
-    tracer?: any;
-    [key: string]: any;
-}
-export type ParseFunction = <Options extends ParseOptions>(input: string, options?: Options) => Options extends {
-    startRule: infer StartRule;
-} ? StartRule extends "start" ? Start : Start : Start;
-export declare const parse: ParseFunction;
-export declare const PeggySyntaxError: typeof _PeggySyntaxError;
-export type PeggySyntaxError = _PeggySyntaxError;
-export type Start = Group | Or | And | Comparison;
-export type Group = Or;
-export type Or = {
-    or: [And | Comparison, ...OrTails[]];
+export type Expression = Or | And | Comparison;
+type Or = {
+    kind: SyntaxKind.Or;
+    operands: Expression[];
 };
-export type OrTails = And | Comparison;
-export type And = {
-    and: [Group | Comparison, ...AndTails[]];
+type And = {
+    kind: SyntaxKind.And;
+    operands: Expression[];
 };
-export type AndTails = Group | Comparison;
-export type Comparison = VerComparison | IntComparison;
-export type IntComparison = {
-    [x: string]: [Term, Term];
+type Comparison = {
+    kind: SyntaxKind.Comparison;
+    left: Identifier;
+    operator: Operator;
+    right: NumberLiteral | Version;
 };
-export type VerComparison = {
-    [x: string]: [Term, Version];
+type Identifier = {
+    kind: SyntaxKind.Identifier;
+    name: string;
 };
-export type Term = Const | String_1 | Hex | Integer;
-export type Const = {
-    var: string;
+type NumberLiteral = {
+    kind: SyntaxKind.NumberLiteral;
+    value: number;
+};
+type Version = {
+    kind: SyntaxKind.Version;
+    value: string;
+};
+export declare enum TokenKind {
+    Identifier = 0,
+    NumberLiteral = 1,
+    Dot = 2,// "."
+    LeftParen = 3,// "("
+    RightParen = 4,// ")"
+    BarBar = 5,// "||"
+    AmpAmp = 6,// "&&"
+    EqualsEquals = 7,// "=="
+    EqualsEqualsEquals = 8,// "==="
+    ExclamationEquals = 9,// "!="
+    ExclamationEqualsEquals = 10,// "!=="
+    LessThan = 11,// "<"
+    LessThanEquals = 12,// "<="
+    GreaterThan = 13,// ">"
+    GreaterThanEquals = 14
+}
+export type Token = {
+    start: number;
+    kind: TokenKind;
+    value?: string;
 };
-export type Integer = number;
-export type Hex = number;
-export type Version = string;
-export type String_1 = string;
-export type _ = string[];
+/**
+ * Splits a string into tokens to be consumed by the Parser.
+ */
+export declare function tokenize(input: string): Generator<Token>;
+export declare function parse(input: string): Expression | undefined;
+export declare function toRulesLogic(expr: Expression): RulesLogic;
 export {};
 //# sourceMappingURL=LogicParser.d.ts.map