@witchcraft/expressit 0.0.2

package/src/utils/getOppositeDelimiter.ts

@@ -0,0 +1,36 @@
+import { unreachable } from "@alanscodelog/utils"
+
+import { isBracket } from "./isBracket.js"
+import { isDelimiter } from "./isDelimiter.js"
+import { isParen } from "./isParen.js"
+import { isQuote } from "./isQuote.js"
+
+import type { ArrayNode, ConditionNode, GroupNode, VariableNode } from "../ast/classes/index.js"
+import { type AnyToken, TOKEN_TYPE, type TokenDelimiterTypes } from "../types/ast.js"
+
+/**
+ * Given a delimiter token, returns it's opposite pair, or undefined if the type passed was not a delimiter token (so you can pass any type without checking).
+ */
+export function getOppositeDelimiter(token: AnyToken): AnyToken<TokenDelimiterTypes> | undefined {
+	if (!isDelimiter(token)) throw new Error("Token is not a delimiter type.")
+	if (isParen(token)) {
+		const paren = (token.parent as GroupNode).paren
+		const opposite = paren.left === token ? "right" : "left"
+		return paren[opposite]
+	} else if (isBracket(token)) {
+		const bracket = (token.parent as ArrayNode).bracket
+		const opposite = bracket.left === token ? "right" : "left"
+		return bracket[opposite]
+	} else if (isQuote(token)) {
+		const quotes = (token.parent as VariableNode).quote
+		if (quotes === undefined) unreachable()
+		const opposite = quotes.left === token ? "right" : "left"
+		return quotes[opposite]
+	} else if (token.type === TOKEN_TYPE.OP_EXPANDED_SEP) {
+		const sep = (token.parent as ConditionNode).sep
+		if (sep === undefined) unreachable()
+		const opposite = sep.left === token ? "right" : "left"
+		return sep[opposite]
+	}
+	unreachable()
+}

package/src/utils/getSurroundingErrors.ts

@@ -0,0 +1,57 @@
+/**
+ * Mostly for internal use by @see autosuggest.
+ *
+ * Returns all error tokens immediately before/after cursor (since there might be multiple error tokens one after the other).
+ *
+ * The errors are sorted by closeness to the given cursor (inside @see CursorInfo), with quote errors having priority, then paren errors, then any other errors. They can be sorted by closeness because although two errors might follow each other, their positions might be different because of whitespace, but they can still be fixed from any cursor position between their ends.
+ *
+ * For example:
+ * ```
+ * a a"
+ *  ^ operator missing at 1
+ *   ^ doublequote missing at 2
+ * if the cursor is at 1 (`a| a"`):
+ * errors = [operator, doublequote]
+ * if the cursor is at 2 (`a |a"`):
+ * errors = [doublequote, operator]
+ *
+ * either insertion would fix the issue for either position would fix the issue, albeit with different results
+ * ```
+ */
+
+import { ErrorToken } from "../ast/classes/ErrorToken.js"
+import { type AnyToken, TOKEN_TYPE } from "../types/ast.js"
+import type { CursorInfo } from "../types/autocomplete.js"
+
+
+export function getSurroundingErrors(tokens: AnyToken[], token: CursorInfo): ErrorToken[] {
+	if (token.at) {return []}
+	const i = tokens.indexOf(token.next ?? token.prev as any)
+
+	let iNext: number = tokens[i] === token.next ? i : i + 1
+	let iPrev: number = tokens[i] === token.next ? i - 1 : i
+
+	const errors = []
+	while (tokens[iNext] instanceof ErrorToken) {
+		errors.push(tokens[iNext])
+		iNext++
+	}
+	while (tokens[iPrev] instanceof ErrorToken) {
+		errors.push(tokens[iPrev])
+		iPrev--
+	}
+
+	return errors.sort((a, b) => {
+		const aIsQuote = [TOKEN_TYPE.DOUBLEQUOTE, TOKEN_TYPE.BACKTICK, TOKEN_TYPE.SINGLEQUOTE].includes(a.expected[0])
+		const bIsQuote = [TOKEN_TYPE.DOUBLEQUOTE, TOKEN_TYPE.BACKTICK, TOKEN_TYPE.SINGLEQUOTE].includes(b.expected[0])
+		const aIsParen = [TOKEN_TYPE.PARENR, TOKEN_TYPE.PARENL].includes(a.expected[0])
+		const bIsParen = [TOKEN_TYPE.PARENR, TOKEN_TYPE.PARENL].includes(b.expected[0])
+		const aCloseness = Math.abs(i - tokens.indexOf(a))
+		const bCloseness = Math.abs(i - tokens.indexOf(b))
+		const closenessComparison = aCloseness - bCloseness
+		if (aIsQuote === bIsQuote) {
+			if (aIsParen !== bIsParen) {return aIsParen ? -1 : 1}
+		}
+		return closenessComparison
+	}) as ErrorToken[]
+}

package/src/utils/index.ts

@@ -0,0 +1,11 @@
+/* Autogenerated Index */
+
+export { extractTokens } from "./extractTokens.js"
+export { getCursorInfo } from "./getCursorInfo.js"
+export { getOppositeDelimiter } from "./getOppositeDelimiter.js"
+export { getSurroundingErrors } from "./getSurroundingErrors.js"
+export { isBracket } from "./isBracket.js"
+export { isDelimiter } from "./isDelimiter.js"
+export { isParen } from "./isParen.js"
+export { isQuote } from "./isQuote.js"
+export { prettyAst } from "./prettyAst.js"

package/src/utils/isBracket.ts

@@ -0,0 +1,6 @@
+import { type AnyToken, TOKEN_TYPE, type TokenBracketTypes } from "../types/ast.js"
+
+
+export function isBracket(token?: AnyToken): token is AnyToken<TokenBracketTypes> {
+	return ([TOKEN_TYPE.BRACKETL, TOKEN_TYPE.BRACKETR] as any[]).includes(token?.type)
+}

package/src/utils/isDelimiter.ts

@@ -0,0 +1,18 @@
+import { type AnyToken, TOKEN_TYPE, type TokenDelimiterTypes } from "../types/ast.js"
+
+/**
+ * Returns whether token is a delimiter type (including if it's an expanded operator separator).
+ */
+export function isDelimiter(token?: AnyToken): token is AnyToken<TokenDelimiterTypes> {
+	return ([
+		TOKEN_TYPE.BACKTICK,
+		TOKEN_TYPE.DOUBLEQUOTE,
+		TOKEN_TYPE.SINGLEQUOTE,
+		TOKEN_TYPE.PARENL,
+		TOKEN_TYPE.PARENR,
+		TOKEN_TYPE.BRACKETL,
+		TOKEN_TYPE.BRACKETR,
+		TOKEN_TYPE.OP_EXPANDED_SEP,
+		TOKEN_TYPE.REGEX,
+	] as TokenDelimiterTypes[]).includes(token?.type as TokenDelimiterTypes)
+}

package/src/utils/isParen.ts

@@ -0,0 +1,6 @@
+import { type AnyToken, TOKEN_TYPE, type TokenParenTypes } from "../types/ast.js"
+
+
+export function isParen(token?: AnyToken): token is AnyToken<TokenParenTypes> {
+	return ([TOKEN_TYPE.PARENL, TOKEN_TYPE.PARENR] as any[]).includes(token?.type)
+}

package/src/utils/isQuote.ts

@@ -0,0 +1,6 @@
+import { type AnyToken, TOKEN_TYPE, type TokenQuoteTypes } from "../types/ast.js"
+
+/** Returns if the token is a quote token. This includes regex delimiters. */
+export function isQuote(token?: AnyToken): token is AnyToken<TokenQuoteTypes> {
+	return ([TOKEN_TYPE.BACKTICK, TOKEN_TYPE.DOUBLEQUOTE, TOKEN_TYPE.SINGLEQUOTE, TOKEN_TYPE.REGEX] as any[]).includes(token?.type)
+}

package/src/utils/prettyAst.ts

@@ -0,0 +1,152 @@
+/* eslint-disable prefer-rest-params */
+import { type AddParameters, colors as color } from "@alanscodelog/utils"
+import { isBlank, unreachable } from "@alanscodelog/utils"
+
+import { ArrayNode, ConditionNode, ErrorToken, ExpressionNode, GroupNode, ValidToken, VariableNode } from "../ast/classes/index.js"
+import { type AnyToken, type ParserResults, TOKEN_TYPE } from "../types/ast.js"
+
+
+type Colors = {
+	/** Color used to highlight the actual text content of the token nodes. */
+	values: string
+	/** Color used to highlight the extra information some nodes contain in their headers for a quick overview (e.g. which operator for expression nodes, if a condition/group value is true, how long an array value is etc). */
+	info: string
+	position: string
+	/** Color used to highlight the hints in parens that indicate how the node is being used (e.g. a variable node might be a property, or alone as a variable, etc) */
+	hint: string
+	error: string
+	/** Color used to reset highlights. */
+	reset: string
+}
+
+const defaultColors: Colors = {
+	values: color.yellow,
+	info: color.cyan,
+	position: color.green,
+	hint: color.blue,
+	error: color.red,
+	reset: color.reset,
+}
+const disableColors: Colors = Object.fromEntries(Object.keys(defaultColors).map(key => [key, ""])) as Colors
+
+const toRows = (rows: string[], opts: Required<NonNullable<Parameters<typeof prettyAst>[1]>>): string[] => {
+	rows = rows.filter(child => child !== "")
+
+	return [
+		...rows.slice(0, rows.length - 1).map(child => `${opts.indent}${opts.children}${child}`),
+		`${opts.indent}${opts.last}${rows[rows.length - 1]}`,
+	]
+}
+/**
+ * Returns a more compressed, color coded, string representation of the ast for debugging.
+ *
+ * There are options to change which symbols are used for tree and if the variables are surrounded by quotes (default false).
+ *
+ * Colors can changed by passing ansi codes (or whatever you want\*) to the third parameter. Or you can pass false instead of an object to disable them. Default colors are:
+ * ```ts
+ * {
+ * 	values: // yellow,
+ * 	position: // green,
+ * 	info: // cyan,
+ * 	hint: // blue,
+ * 	error: // red,
+ * 	reset: // ansi reset code
+ * }
+ * ```
+ * \* For example, you could pass html tags to show this in the browser instead (this is how the demo works). This is why the reset color is exposed. For example, a color might be `<span class="error">` and reset can be `</span>`.
+ */
+
+export function prettyAst(
+	ast: ParserResults | AnyToken | VariableNode | ArrayNode | GroupNode,
+	{ indent = "   ", children = "├╴", last = "└╴", branch = "│", quote = "" }: Partial<Record<"indent" | "children" | "last" | "branch" | "quote", string>> = {},
+	colors: Partial<Colors> | false = {},
+): string {
+	const opts = { indent, children, last, branch, quote }
+	const c: Colors = colors ? { ...defaultColors, ...colors } : disableColors
+	const pos = `${c.position}(${ast.start}, ${ast.end})${c.reset}`
+	const _ = indent
+	// accumulated indent
+	const __: string = arguments[3] ?? ""
+	let extra: string = arguments[4] ?? ""
+	if (!isBlank(extra)) extra = ` ${c.hint}${extra}${c.reset}`
+	// indent to add to children items
+	const ___ = __ + _ + branch
+	// indent to add to last child item
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	const __L = __ + _ + indent[0]
+	const prettyAst_ = prettyAst as any as AddParameters<typeof prettyAst, [
+		typeof __,
+		typeof extra,
+	]>
+	if (ast instanceof ValidToken) {
+		const value = `${ast.value}`
+		return `TOKEN ${pos} ${c.values}${quote}${value}${quote}${c.reset}${extra}`
+	}
+	if (ast instanceof ErrorToken) {
+		const value = `[${ast.expected.join(", ")}]`
+		return `ERROR ${pos} ${c.error}${value}${c.reset}${extra}`
+	}
+	if (ast instanceof ConditionNode) {
+		const header = `${c.info}${ast.operator === undefined}${c.reset}`
+		const not = ast.operator ? prettyAst_(ast.operator, opts, c, ___, `(negation)`) : ""
+		const property = ast.property ? prettyAst_(ast.property, opts, c, ___, `(property)`) : ""
+		const sepL = ast.sep?.left ? prettyAst_(ast.sep.left, opts, c, ___, `(separator)`) : ""
+		const op = ast.propertyOperator ? prettyAst_(ast.propertyOperator, opts, c, ___, `(property operator)`) : ""
+		const sepR = ast.sep?.right ? prettyAst_(ast.sep.right, opts, c, ___, `(separator)`) : ""
+		const isRegex = ast.value instanceof VariableNode && ast.value.quote?.left.type === TOKEN_TYPE.REGEX
+		const isArray = ast.value instanceof ArrayNode
+		const variable = prettyAst_(ast.value, opts, c, __L, `(${property ? "value" : "variable/alone"}${isRegex ? " - regex" : isArray ? "- array" : ""})`)
+		return [
+			`CONDITION ${pos} ${header}${extra}`,
+			...toRows([not, property, sepL, op, sepR, variable], opts),
+		].join(`\n${__}`)
+	}
+	if (ast instanceof VariableNode) {
+		const prefix = ast.prefix ? prettyAst_(ast.prefix, opts, c, ___, `(value prefix)`) : ""
+		const left = ast.quote?.left ? prettyAst_(ast.quote.left, opts, c, ___, "") : ""
+		const value = prettyAst_(ast.value, opts, c, !ast.quote ? __L : !ast.quote?.right ? __L : ___, "")
+		const right = ast.quote?.right ? prettyAst_(ast.quote.right, opts, c, !ast.quote?.flags ? __L : ___, "") : ""
+		const flags = ast.quote?.flags ? prettyAst_(ast.quote.flags, opts, c, __L, "(flags)") : ""
+
+		return [
+			`VARIABLE ${pos}${extra}`,
+			...toRows([prefix, left, value, right, flags], opts),
+		].join(`\n${__}`)
+	}
+	if (ast instanceof GroupNode) {
+		const header = `${c.info}${ast.prefix === undefined || (ast.prefix as ConditionNode).operator === undefined}${c.reset}`
+		const prefix = ast.prefix ? prettyAst_(ast.prefix, opts, c, ___, `(group prefix)`) : ""
+		const expression = prettyAst_(ast.expression, opts, c, __L, "")
+		return [
+			`GROUP ${pos}${!extra.includes("value") ? ` ${header}` : ""}${extra}`,
+			...toRows([prefix, expression], opts),
+		].join(`\n${__}`)
+	}
+	if (ast instanceof ArrayNode) {
+		const bracketL = ast.bracket.left ? prettyAst_(ast.bracket.left, opts, c, ast.values.length === 0 && !ast.bracket.right ? __L : ___, "") : ""
+		const values = ast.values.length > 0
+			? ast.values.map((node, i) =>
+				prettyAst_(node, opts, c, !ast.bracket.right && i === ast.values.length - 1 ? __L : ___, "")
+			)
+			: []
+		const bracketR = ast.bracket.right ? prettyAst_(ast.bracket.right, opts, c, __L, "") : ""
+		return [
+			`ARRAY ${pos} ${c.info}[${ast.values.length}]${c.reset}${extra}`,
+			...toRows([bracketL, ...values, bracketR], opts),
+		].join(`\n${__}`)
+	}
+	if (ast instanceof ExpressionNode) {
+		const left = prettyAst_(ast.left, opts, c, ___, "")
+		const operator = prettyAst_(ast.operator, opts, c, ___, `(boolean operator)`)
+		const right = prettyAst_(ast.right, opts, c, __L, "")
+
+		const header = ast.operator instanceof ErrorToken
+			? `${c.info}[${ast.operator.expected.join(",")}]${c.reset}`
+			: `${c.info}"${ast.operator.value}"${c.reset}`
+		return [
+			`EXPRESSION ${pos} ${header}${extra}`,
+			...toRows([left, operator, right], opts),
+		].join(`\n${__}`)
+	}
+	unreachable()
+}