@witchcraft/expressit 0.0.2

package/src/helpers/parser/checkParserOpts.ts

@@ -0,0 +1,143 @@
+import { isBlank, pushIfNotIn } from "@alanscodelog/utils"
+
+import { ERROR_CODES } from "../../types/errors.js"
+import type { FullParserOptions, ParserOptions } from "../../types/parser.js"
+import { BooleanParserLibraryError } from "../errors.js"
+import { defaultConditionNormalizer } from "../general/defaultConditionNormalizer.js"
+import { defaultValueComparer } from "../general/defaultValueComparer.js"
+
+
+export function checkParserOpts<T extends {}>(opts: FullParserOptions<T>, evaluatorChecks: boolean = false, validatorChecks: boolean = false): void {
+	if (!evaluatorChecks) {
+		const keywordsList = [...opts.keywords.and, ...opts.keywords.or, ...opts.keywords.not].map(keyword => keyword.value)
+		const symNots = opts.keywords.not.filter(op => op.isSymbol).map(op => op.value)
+		const keywords = [
+			...[...keywordsList].filter(val => !symNots.includes(val)),
+			...["(", ")"],
+			...(opts.arrayValues ? ["[", "]"] : []),
+			...(opts.regexValues ? ["/"] : []),
+		]
+		const extra: string[] = []
+		if (opts.expandedPropertySeparator) extra.push(opts.expandedPropertySeparator)
+		if (opts.customPropertyOperators) pushIfNotIn(extra, ...opts.customPropertyOperators)
+
+
+		/* #region Blank Operator Checks */
+		if (opts.expandedPropertySeparator && isBlank(opts.expandedPropertySeparator)) {
+			throw new BooleanParserLibraryError(
+				ERROR_CODES.PARSER_CONFLICTING_OPTIONS_ERROR,
+				{ prohibited: [""], invalid: opts.expandedPropertySeparator },
+			`expandedPropertySeparator cannot be blank`
+			)
+		}
+		const customInvalid = opts.customPropertyOperators?.find(_ => isBlank(_))
+		if (customInvalid !== undefined) {
+			throw new BooleanParserLibraryError(
+				ERROR_CODES.PARSER_CONFLICTING_OPTIONS_ERROR,
+				{ prohibited: [""], invalid: customInvalid },
+			`customPropertyOperators cannot contain blank entries`
+			)
+		}
+		const prefixInvalid = opts.prefixableStrings?.find(_ => isBlank(_))
+		if (prefixInvalid !== undefined) {
+			throw new BooleanParserLibraryError(
+				ERROR_CODES.PARSER_CONFLICTING_OPTIONS_ERROR,
+				{ prohibited: [""], invalid: prefixInvalid },
+			`prefixableStrings cannot contain blank entries`
+			)
+		}
+		for (const key of ["and", "or", "not"]) {
+			const invalid = opts.keywords[key as keyof FullParserOptions["keywords"]]
+				?.find(_ => isBlank(_.value))
+				?.value
+			if (invalid !== undefined) {
+				throw new BooleanParserLibraryError(
+					ERROR_CODES.PARSER_CONFLICTING_OPTIONS_ERROR,
+					{ prohibited: [""], invalid },
+				`keywords.${key} cannot contain entries with blank values`
+				)
+			}
+		}
+		/* #regionend */
+
+		/* #region Prohibited Keyword Checks */
+		const all = [...keywords, ...symNots, ...extra]
+		const allKeywords = [...keywords, ...symNots]
+		/**
+		 * Allowed:
+		 * - custom property operators can be the same as symbol not operators
+		 * - custom property operators can be the same as expanded property separators
+		 */
+
+		const messageInvalidAny = "cannot contain operators or special symbols, but found"
+		const messageInvalidBool = "cannot contain boolean operators or special symbols, but found"
+
+		const invalidPrefixableString = opts.prefixableStrings?.find(val => all.includes(val))
+		if (invalidPrefixableString) {
+			throw new BooleanParserLibraryError(
+				ERROR_CODES.PARSER_CONFLICTING_OPTIONS_ERROR,
+				{ prohibited: all, invalid: invalidPrefixableString },
+			`prefixableStrings ${messageInvalidAny} "${invalidPrefixableString}"`
+			)
+		}
+
+		const invalidExpandedPropertySeparator = allKeywords
+			.find(_ => _ === opts.expandedPropertySeparator as any)
+		if (invalidExpandedPropertySeparator) {
+			throw new BooleanParserLibraryError(
+				ERROR_CODES.PARSER_CONFLICTING_OPTIONS_ERROR,
+				{ prohibited: allKeywords, invalid: invalidExpandedPropertySeparator },
+			`expandedPropertySeparator ${messageInvalidBool} "${invalidExpandedPropertySeparator}"`
+			)
+		}
+
+		const invalidCustomPropertyOperator = opts.customPropertyOperators?.find(val => keywords.includes(val))
+		? opts.expandedPropertySeparator
+		: undefined
+		if (invalidCustomPropertyOperator) {
+			throw new BooleanParserLibraryError(
+				ERROR_CODES.PARSER_CONFLICTING_OPTIONS_ERROR,
+				{ prohibited: keywords, invalid: invalidCustomPropertyOperator },
+			`customPropertyOperator ${messageInvalidBool} "${invalidCustomPropertyOperator}"`
+			)
+		}
+		/* #regionend */
+	}
+
+	if (evaluatorChecks) {
+		const requireCustomNormalizer: (keyof ParserOptions)[] = [] as any
+		if ((opts.prefixableStrings?.length ?? 0) > 0) requireCustomNormalizer.push("prefixableStrings")
+		if ((opts.customPropertyOperators?.length ?? 0) > 0) requireCustomNormalizer.push("customPropertyOperators")
+		if ((opts.expandedPropertySeparator?.length ?? 0) > 0) requireCustomNormalizer.push("expandedPropertySeparator")
+		if (opts.regexValues) requireCustomNormalizer.push("regexValues")
+
+		if (requireCustomNormalizer.length > 0 && opts.conditionNormalizer === defaultConditionNormalizer) {
+			throw new BooleanParserLibraryError(
+				ERROR_CODES.PARSER_OPTION_REQUIRED_ERROR,
+				{ options: requireCustomNormalizer, requires: "conditionNormalizer" },
+				`A custom conditionNormalizer function must be specified when using the following options: ${requireCustomNormalizer.join(", ")}`
+			)
+		}
+		const requireCustomComparer: (keyof ParserOptions)[] = [] as any
+		if (opts.regexValues) requireCustomComparer.push("regexValues")
+		if (opts.regexValues) requireCustomComparer.push("arrayValues")
+
+		if (requireCustomComparer.length > 0 && opts.valueComparer === defaultValueComparer) {
+			throw new BooleanParserLibraryError(
+				ERROR_CODES.PARSER_OPTION_REQUIRED_ERROR,
+				{ options: requireCustomComparer, requires: "valueComparer" },
+					`A custom valueComparer function must be specified when using the following options: ${requireCustomComparer.join(", ")}`
+			)
+		}
+	}
+	if (validatorChecks) {
+		if (opts.valueValidator === undefined) {
+			throw new BooleanParserLibraryError(
+				ERROR_CODES.PARSER_OPTION_REQUIRED_ERROR,
+				{ requires: "valueValidator" },
+				`A custom valueValidator function must be specified when using the validate method.`
+			)
+		}
+	}
+}
+

package/src/helpers/parser/extractPosition.ts

@@ -0,0 +1,15 @@
+import type { Position } from "../../types/ast.js"
+
+
+type ChevrotainLocation = {
+	startOffset?: number
+	endOffset?: number
+}
+
+/** @internal */
+export function extractPosition(loc: ChevrotainLocation, shift: number): Position {
+	return {
+		start: loc.startOffset! - (shift ?? 0),
+		end: loc.endOffset! + 1 - (shift ?? 0),
+	}
+}

package/src/helpers/parser/getUnclosedRightParenCount.ts

@@ -0,0 +1,22 @@
+import { type IToken, tokenMatcher } from "chevrotain"
+
+import type { createTokens } from "../../grammar/createTokens.js"
+
+
+/** @internal */
+export function getUnclosedRightParenCount(tokens: IToken[], t: ReturnType<typeof createTokens>["tokens"]): number {
+	let open = 0
+	let unclosed = 0
+	for (const token of tokens) {
+		if (tokenMatcher(token, t.PAREN_R)) {
+			if (open > 0) {
+				open--
+			} else {
+				unclosed++
+			}
+		} else if (tokenMatcher(token, t.PAREN_L)) {
+			open++
+		}
+	}
+	return unclosed
+}

package/src/helpers/parser/index.ts

@@ -0,0 +1,10 @@
+/* Autogenerated Index */
+
+export { assignParents } from "./assignParents.js"
+export { checkParserOpts } from "./checkParserOpts.js"
+export { extractPosition } from "./extractPosition.js"
+export { getUnclosedRightParenCount } from "./getUnclosedRightParenCount.js"
+export { parseParserOptions } from "./parseParserOptions.js"
+export { seal } from "./seal.js"
+export { setParent } from "./setParent.js"
+export { unescape } from "./unescape.js"

package/src/helpers/parser/parseParserOptions.ts

@@ -0,0 +1,54 @@
+import type { FullParserOptions, ParserOptions } from "../../types/parser.js"
+import { defaultConditionNormalizer } from "../general/defaultConditionNormalizer.js"
+import { defaultKeyParser } from "../general/defaultKeyParser.js"
+import { defaultPrefixApplier } from "../general/defaultPrefixApplier.js"
+import { defaultValueComparer } from "../general/defaultValueComparer.js"
+
+/** @internal */
+export function parseParserOptions<T extends {} = {}>(
+	options: ParserOptions<T>
+): FullParserOptions<T> {
+	const opts: ParserOptions = {
+		prefixApplier: defaultPrefixApplier,
+		keyParser: defaultKeyParser,
+		valueComparer: defaultValueComparer,
+		conditionNormalizer: defaultConditionNormalizer,
+		prefixableGroups: true,
+		prefixableStrings: undefined,
+		expandedPropertySeparator: undefined,
+		customPropertyOperators: undefined,
+		onMissingBooleanOperator: "error",
+		arrayValues: true,
+		regexValues: true,
+		...options, // todo fix
+		keywords: {
+			or:
+				options.keywords?.or
+				? options.keywords.or as any
+				: [
+					{ value: "||", isSymbol: true },
+					{ value: "|", isSymbol: true },
+					{ value: "or", isSymbol: false },
+					{ value: "OR", isSymbol: false },
+				],
+			and:
+				options.keywords?.and
+				? options.keywords.and as any
+				: [
+					{ value: "&&", isSymbol: true },
+					{ value: "&", isSymbol: true },
+					{ value: "and", isSymbol: false },
+					{ value: "AND", isSymbol: false },
+				],
+			not:
+				options.keywords?.not
+				? options.keywords.not as any
+				: [
+					{ value: "!", isSymbol: true },
+					{ value: "not", isSymbol: false },
+					{ value: "NOT", isSymbol: false },
+				],
+		},
+	}
+	return opts as any
+}

package/src/helpers/parser/seal.ts

@@ -0,0 +1,14 @@
+import { assignParents } from "./assignParents.js"
+
+import { Node } from "../../ast/classes/Node.js"
+import type { AnyToken, Nodes } from "../../types/ast.js"
+
+/**
+ * set and "seals" all parent properties
+ *
+ * @internal
+ */
+export function seal(ast: Nodes | AnyToken): void {
+	if (ast instanceof Node) assignParents(ast)
+	ast.parent = undefined
+}

package/src/helpers/parser/setParent.ts

@@ -0,0 +1,5 @@
+/**
+ * @internal
+ * @see assignParents
+ */
+export const setParent: unique symbol = Symbol("private set parent key")

package/src/helpers/parser/unescape.ts

@@ -0,0 +1,4 @@
+/** @internal */
+export function unescape(str: string): string {
+	return str.replace(/\\{1,1}(.)/g, "$1")
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+/* Manually Generated Index */
+export * as ast from "./ast/classes/index.js"
+export * as grammar from "./grammar/index.js"
+export { Parser } from "./parser.js"
+export * from "./types/index.js"
+export * as utils from "./utils/index.js"
+

package/src/methods/autocomplete.ts

@@ -0,0 +1,128 @@
+import { unreachable } from "@alanscodelog/utils"
+
+import { ConditionNode } from "../ast/classes/ConditionNode.js"
+import { VariableNode } from "../ast/classes/VariableNode.js"
+import type { Parser } from "../parser.js"
+import { type Completion, type Suggestion, SUGGESTION_TYPE } from "../types/autocomplete.js"
+import type { FullParserOptions } from "../types/parser.js"
+
+
+export class AutocompleteMixin<T extends {}> {
+	/**
+	 * Given a list of @see Suggestion entries, the parser options, and a list of variables, prefixes, operators, etc, and the preferred quote type, returns a list of @see Completion entries.
+	 *
+	 * It takes care of suggesting the correct delimiters for fixes, quoting variables/prefixes if it would not be possible to parse them unquoted, and separating symbol from non-symbol (word) operators.
+	 *
+	 * Does not add whitespace or group requirements. The suggestion information is still in the completion if you wish to show these. But they should not be added to the completion value if using @see autoreplace which will take care of it.
+	 *
+	 * Is not aware of existing values. You will have to use @see getCursorInfo to understand the context in which the suggestion was made, so that, for example, you could filter out used regex flags.
+	 */
+	autocomplete(
+		suggestions: Suggestion[],
+		{
+			values = [], arrayValues = [], variables = [], prefixes = [], properties = [], expandedPropertyOperators = [], customPropertyOperators = (this as any as Parser<T>).options.customPropertyOperators ?? [], keywords = (this as any as Parser<T>).options.keywords, regexFlags = ["i", "m", "u"], quote = "\"",
+		}: Partial<Record<
+			"variables" |
+			"values" |
+			"arrayValues" |
+			"prefixes" |
+			"properties" |
+			"regexFlags" |
+			"expandedPropertyOperators" |
+			"customPropertyOperators", string[]>> & {
+			quote?: string
+			keywords?: FullParserOptions<T>["keywords"]
+		} = {}
+	): Completion[] {
+		const self = (this as any as Parser<T>)
+		return suggestions.map(suggestion => {
+			const type = suggestion.type
+			switch (type) {
+				case SUGGESTION_TYPE.BACKTICK: return [{ suggestion, value: "`" }]
+				case SUGGESTION_TYPE.DOUBLEQUOTE: return [{ suggestion, value: "\"" }]
+				case SUGGESTION_TYPE.SINGLEQUOTE: return [{ suggestion, value: "'" }]
+				case SUGGESTION_TYPE.PARENL: return [{ suggestion, value: "(" }]
+				case SUGGESTION_TYPE.PARENR: return [{ suggestion, value: ")" }]
+				case SUGGESTION_TYPE.BRAKCETR: return [{ suggestion, value: "]" }] // L not needed
+				case SUGGESTION_TYPE.REGEX: return [{ suggestion, value: "/" }]
+				case SUGGESTION_TYPE.REGEX_FLAGS:
+					return regexFlags
+						.map(value => ({ suggestion, value }))
+						// remove existing flags from suggestions
+						.filter(completion => {
+							// eslint-disable-next-line @typescript-eslint/no-shadow
+							const { suggestion, value } = completion
+							if (suggestion.type !== SUGGESTION_TYPE.REGEX_FLAGS) {return true}
+
+							const token = suggestion.cursorInfo
+							const flags = token.at && (token.at.parent as VariableNode)?.quote?.flags === suggestion.cursorInfo.at
+								? token.at
+								: token.next && (token.next.parent as VariableNode)?.quote?.flags === suggestion.cursorInfo.next
+									? token.next
+									: token.prev && (token.prev.parent as VariableNode)?.quote?.flags === suggestion.cursorInfo.prev
+										? token.prev
+										: undefined
+
+							if (flags?.value?.includes(value)) {return false}
+							return true
+						})
+				case SUGGESTION_TYPE.PROPERTY: {
+					return properties.map(value => ({ suggestion, value }))
+				}
+				case SUGGESTION_TYPE.PROPERTY_SEP: {
+					return [{ suggestion, value: self.options.expandedPropertySeparator! }]
+				}
+				case SUGGESTION_TYPE.EXPANDED_PROPERTY_OPERATOR: {
+					return expandedPropertyOperators.map(value => ({ suggestion, value }))
+				}
+				case SUGGESTION_TYPE.CUSTOM_PROPERTY_OPERATOR: {
+					return customPropertyOperators.map(value => ({ suggestion, value }))
+				}
+				case SUGGESTION_TYPE.BOOLEAN_SYMBOL_OP: {
+					const keywordsList = [...keywords.and, ...keywords.or]
+					const symOpts = keywordsList.filter(_ => _.isSymbol)
+					return symOpts.map(({ value }) => ({ suggestion, value }))
+				}
+				case SUGGESTION_TYPE.BOOLEAN_WORD_OP: {
+					const keywordsList = [...keywords.and, ...keywords.or]
+					const wordOpts = keywordsList.filter(_ => !_.isSymbol)
+					return wordOpts.map(({ value }) => ({ suggestion, value }))
+				}
+				case SUGGESTION_TYPE.VALUE:
+				case SUGGESTION_TYPE.ARRAY_VALUE:
+				case SUGGESTION_TYPE.VARIABLE: {
+					const arr = type === SUGGESTION_TYPE.VARIABLE
+						? variables
+						: type === SUGGESTION_TYPE.ARRAY_VALUE
+							? arrayValues
+							: type === SUGGESTION_TYPE.VALUE
+								? values
+								: unreachable()
+					return arr.map(variable => {
+						// we don't need to alter options since we can just check there are no quotes (also tells us no prefixes are used) and no operators are defined
+						const res = self.parse(variable)
+						if (res instanceof ConditionNode &&
+							res.operator === undefined &&
+							res.value instanceof VariableNode &&
+							res.value.quote === undefined) {
+							return { suggestion, value: res.value.value.value }
+						} else {
+							return { suggestion, value: quote + variable.replace(new RegExp(quote, "g"), `\\${quote}`) + quote }
+						}
+					})
+				}
+				case SUGGESTION_TYPE.PREFIX: return prefixes.map(prefix => {
+					const res = self.parse(prefix)
+					if (res instanceof ConditionNode &&
+						res.operator === undefined &&
+						res.value instanceof VariableNode &&
+						res.value.quote === undefined) {
+						return { suggestion, value: res.value.value.value }
+					} else {
+						return { suggestion, value: quote + prefix.replace(new RegExp(quote, "g"), `\\${quote}`) + quote }
+					}
+				})
+			}
+		}).flat()
+	}
+}

package/src/methods/autoreplace.ts

@@ -0,0 +1,46 @@
+import { insert } from "@alanscodelog/utils"
+
+import type { Completion } from "../types/autocomplete.js"
+
+
+export class AutoreplaceMixin {
+	/**
+	 * Given the input string and a @see Completion consisting of the value of the replacement and a @see Suggestion entry, returns the replacement string and the new position of the cursor.
+	 *
+	 * The value passed should be escaped if it's needed (or quoted). @see autocomplete already takes care of quoting variables if you're using it.
+	 */
+	autoreplace(
+		input: string,
+		{ value, suggestion }: Completion
+	): { replacement: string, cursor: number } {
+		const isQuotedLeft = ["\"", "'", "`"].includes(value[0])
+		const isQuotedRight = ["\"", "'", "`"].includes(value[value.length - 1])
+		if ((isQuotedLeft && !isQuotedRight) || (!isQuotedLeft && isQuotedRight)) {
+			throw new Error(`Completion value must either be entirely quoted or entirely unquoted. But the left side is ${isQuotedLeft ? "quoted" : "unquoted"} and the right side is ${isQuotedRight ? "quoted" : "unquoted"}.`)
+		}
+		let cursor = suggestion.range.start + value.length
+
+		if (suggestion.requires.prefix) {
+			value = suggestion.requires.prefix + (isQuotedLeft ? "" : "\"") + value + (isQuotedRight ? "" : "\"")
+
+			cursor += suggestion.requires.prefix.length + Number(!isQuotedLeft) + Number(!isQuotedRight)
+		}
+		if (suggestion.requires.group) {
+			value += "()"
+			cursor++
+		}
+
+		if (suggestion.requires.whitespace.before // &&
+		) {
+			value = ` ${value}`
+			cursor++
+		}
+		if (suggestion.requires.whitespace.after // &&
+		) {
+			value = `${value} `
+		}
+
+		const replacement = insert(value, input, [suggestion.range.start, suggestion.range.end])
+		return { replacement, cursor }
+	}
+}