@witchcraft/expressit 0.0.2

package/dist/examples/advancedValueComparer.js

@@ -0,0 +1,28 @@
+function valueComparer(contextValue, { operator, prefix, value, isRegex, regexFlags }) {
+  let finalValue = value;
+  if (prefix) {
+    const val = value;
+    switch (prefix) {
+      case "num":
+        finalValue = parseInt(val, 2);
+        break;
+    }
+  }
+  if (isRegex) {
+    const val = value;
+    const regex = new RegExp(val, regexFlags);
+    return contextValue.match(regex) !== null;
+  }
+  if (operator) {
+    switch (operator) {
+      case ">":
+        return contextValue > finalValue;
+      case "contains":
+        return contextValue.includes(finalValue);
+    }
+  }
+  return contextValue === finalValue;
+}
+export {
+  valueComparer
+};

package/dist/examples/shortcutContextParser.d.ts

@@ -0,0 +1,22 @@
+/**
+ * A pre-configured parser for parsing shortcut contexts (similar to VSCode's [when clause contexts](https://code.visualstudio.com/docs/getstarted/keybindings#_when-clause-contexts)).
+ *
+ * The only difference is that it does not have a regex operator since you can just do `prop == /regex/`, and because of how it has `prefixableGroups` turned on and how the parser allows groups as values, user's can use shorter queries.
+ *
+ * It also automatically implements a prefixApplier (variables are joined with `.`) and a value validator (which is why it requires a dummy context and a list of valid regex flags be passed). The value of the dummy context should be true to indicate the key is regexable, otherwise just false or a nested object. Any nested keys found are joined with a `.` and added to a list of valid keys. The prefixApplier is loose and allows things like `a.(b.(c))` and `a(b(c))` to both be parsed as `a.b.c`.
+ *
+ * The validate function will return a list of positions with a list of errors which includes handling invalid or duplicate regex flags.
+ */
+import { Parser } from "../parser.js";
+import type { Position } from "../types/ast.js";
+export declare class ShortcutContextParser<T extends Position & {
+    type: ("invalidKey" | "unregexableKey" | "invalidRegexFlag" | "duplicateRegexFlag");
+} = Position & {
+    type: ("invalidKey" | "unregexableKey" | "invalidRegexFlag" | "duplicateRegexFlag");
+}> extends Parser<T> {
+    validKeys: string[];
+    regexablekeys: string[];
+    constructor(dummyContext: Record<string, any>, validRegexFlags?: string[]);
+    private _extractKeysFromContext;
+}
+//# sourceMappingURL=shortcutContextParser.d.ts.map

package/dist/examples/shortcutContextParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shortcutContextParser.d.ts","sourceRoot":"","sources":["../../src/examples/shortcutContextParser.ts"],"names":[],"mappings":"AACA;;;;;;;;GAQG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAI/C,qBAAa,qBAAqB,CAAC,CAAC,SACnC,QAAQ,GAAG;IAAE,IAAI,EAAE,CAAC,YAAY,GAAG,gBAAgB,GAAG,kBAAkB,GAAG,oBAAoB,CAAC,CAAA;CAAE,GAClG,QAAQ,GAAG;IAAE,IAAI,EAAE,CAAC,YAAY,GAAG,gBAAgB,GAAG,kBAAkB,GAAG,oBAAoB,CAAC,CAAA;CAAE,CACjG,SAAQ,MAAM,CAAC,CAAC,CAAC;IAClB,SAAS,EAAE,MAAM,EAAE,CAAK;IAExB,aAAa,EAAE,MAAM,EAAE,CAAK;gBAG3B,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACjC,eAAe,GAAE,MAAM,EAAoB;IAmG5C,OAAO,CAAC,uBAAuB;CAa/B"}

package/dist/examples/shortcutContextParser.js

@@ -0,0 +1,126 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import { Parser } from "../parser.js";
+class ShortcutContextParser extends Parser {
+  constructor(dummyContext, validRegexFlags = ["i", "u", "m"]) {
+    super({
+      arrayValues: false,
+      keyParser: (key) => key.split(/\.+/),
+      keywords: {
+        and: [{ isSymbol: true, value: "&&" }],
+        or: [{ isSymbol: true, value: "||" }],
+        not: [{ isSymbol: true, value: "!" }]
+      },
+      regexValues: (property, operator) => property !== void 0 && operator !== void 0,
+      customPropertyOperators: ["!=", "=="],
+      prefixableGroups: true,
+      prefixApplier: (prefix, variable) => {
+        if (!prefix.endsWith(".")) {
+          return `${prefix}.${variable}`;
+        }
+        return prefix + variable;
+      },
+      valueComparer: (_condition, contextValue, query) => {
+        if (query.isRegex) {
+          return contextValue.match(new RegExp(query.value, query.regexFlags ?? "")) !== null;
+        }
+        return contextValue === query.value;
+      },
+      valueValidator: (_contextValue, query) => {
+        let tokens = [];
+        if (!this.validKeys.includes(query.propertyName)) {
+          tokens = tokens.concat(query.property.map((token) => ({
+            start: token.start,
+            end: token.end,
+            type: "invalidKey"
+          })));
+        }
+        if (query.isRegex && !this.regexablekeys.includes(query.propertyName)) {
+          tokens = tokens.concat(query.property.map((token) => ({
+            start: token.start,
+            end: token.end,
+            type: "unregexableKey"
+          })));
+        }
+        if (query.regexFlags) {
+          const chars = query.regexFlags.value.split("");
+          const start = query.regexFlags.start;
+          for (let i = 0; i < chars.length; i++) {
+            const char = chars[i];
+            if (chars.slice(0, i).includes(char)) {
+              tokens.push({
+                start: start + i,
+                end: start + i + 1,
+                type: "duplicateRegexFlag"
+              });
+            }
+            if (!validRegexFlags.includes(char)) {
+              tokens.push({
+                start: start + i,
+                end: start + i + 1,
+                type: "invalidRegexFlag"
+              });
+            }
+          }
+        }
+        if (tokens.length > 0)
+          return tokens;
+      },
+      conditionNormalizer({ operator, value, regexFlags, isRegex, isNegated, isQuoted }) {
+        let finalValue = value;
+        let finalOperator = operator;
+        if (typeof value === "string" && !isQuoted) {
+          const asNum = parseInt(value, 2);
+          if (!isNaN(asNum))
+            finalValue = asNum;
+          if (["true", "false"].includes(value)) {
+            finalValue = value === "true";
+          }
+        }
+        if (isRegex) {
+          const val = value;
+          const regex = new RegExp(val, regexFlags);
+          finalValue = regex;
+        }
+        if (operator) {
+          switch (operator) {
+            case "==": {
+              finalOperator = "equals";
+              break;
+            }
+            case "!=": {
+              finalOperator = "equals";
+              isNegated = !isNegated;
+              break;
+            }
+          }
+        }
+        return { value: finalValue, operator: finalOperator, negate: isNegated };
+      }
+    });
+    __publicField(this, "validKeys", []);
+    __publicField(this, "regexablekeys", []);
+    this._extractKeysFromContext(dummyContext);
+  }
+  _extractKeysFromContext(context, prev) {
+    for (const key of Object.keys(context)) {
+      if (typeof context[key] === "boolean") {
+        this.validKeys.push(prev ? `${prev}.${key}` : key);
+        if (context[key] === true) {
+          this.regexablekeys.push(prev ? `${prev}.${key}` : key);
+        }
+      } else {
+        if (typeof context[key] !== "object")
+          throw new Error("A dummy context value must be a boolean or an object.");
+        this._extractKeysFromContext(context[key], prev ? `${prev}.${key}` : key);
+      }
+    }
+  }
+}
+export {
+  ShortcutContextParser
+};

package/dist/global.d.js

@@ -0,0 +1 @@
+

package/dist/grammar/ParserBase.d.ts

@@ -0,0 +1,51 @@
+import { EmbeddedActionsParser, type IToken } from "chevrotain";
+import type { createTokens } from "./createTokens.js";
+import { ArrayNode } from "../ast/classes/ArrayNode.js";
+import { ConditionNode } from "../ast/classes/ConditionNode.js";
+import type { ExpressionNode } from "../ast/classes/ExpressionNode.js";
+import type { GroupNode } from "../ast/classes/GroupNode.js";
+import type { ValidToken } from "../ast/classes/ValidToken.js";
+import { VariableNode } from "../ast/classes/VariableNode.js";
+import { type AnyToken, type ParserResults, TOKEN_TYPE, type TokenQuoteTypes } from "../types/ast.js";
+import type { FullParserOptions } from "../types/parser.js";
+export declare class ParserBase<T extends {} = {}> extends EmbeddedActionsParser {
+    rawInput: string;
+    private subParser?;
+    private subParser2?;
+    constructor(opts: FullParserOptions<T>, t: ReturnType<typeof createTokens>["tokens"], { customOpAlsoNegation, expandedSepAlsoCustom }: ReturnType<typeof createTokens>["info"]);
+}
+export interface ParserBase {
+    shift: number;
+    main: () => ParserResults;
+    anySym: () => IToken;
+    boolOr: () => ExpressionNode;
+    boolAnd: () => ExpressionNode;
+    condition: () => ConditionNode | GroupNode;
+    property: () => {
+        prop?: VariableNode;
+        rest: {
+            sepL?: ValidToken<TOKEN_TYPE.OP_EXPANDED_SEP>;
+            sepR?: ValidToken<TOKEN_TYPE.OP_EXPANDED_SEP>;
+            propertyOperator?: ConditionNode["propertyOperator"];
+        };
+    };
+    plainGroup: () => [ValidToken<TOKEN_TYPE.PARENL>, GroupNode["expression"], ValidToken<TOKEN_TYPE.PARENR> | undefined];
+    plainBracketGroup: () => ArrayNode;
+    not: () => ValidToken<TOKEN_TYPE.NOT>;
+    variable: () => VariableNode;
+    valueDelimAny: () => AnyToken<TokenQuoteTypes>;
+    quoteSingle: () => AnyToken<TOKEN_TYPE.SINGLEQUOTE>;
+    quoteDouble: () => AnyToken<TOKEN_TYPE.DOUBLEQUOTE>;
+    quoteBacktick: () => AnyToken<TOKEN_TYPE.BACKTICK>;
+    regexAny: () => AnyToken<TOKEN_TYPE.REGEX> | [AnyToken<TOKEN_TYPE.REGEX>, ValidToken<TOKEN_TYPE.VALUE>];
+    valueNotSingle: () => AnyToken<TOKEN_TYPE.VALUE>;
+    valueNotDouble: () => AnyToken<TOKEN_TYPE.VALUE>;
+    valueNotBacktick: () => AnyToken<TOKEN_TYPE.VALUE>;
+    valueUnquoted: () => AnyToken<TOKEN_TYPE.VALUE>;
+    valueRegex: () => AnyToken<TOKEN_TYPE.VALUE>;
+    parenL: () => ValidToken<TOKEN_TYPE.PARENL>;
+    parenR: () => ValidToken<TOKEN_TYPE.PARENR> | undefined;
+    bracketL: () => ValidToken<TOKEN_TYPE.BRACKETL>;
+    bracketR: () => ValidToken<TOKEN_TYPE.BRACKETR> | undefined;
+}
+//# sourceMappingURL=ParserBase.d.ts.map

package/dist/grammar/ParserBase.d.ts.map

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