@witchcraft/expressit 0.2.2 → 0.3.1

package/src/ast/createToken.ts

@@ -1,21 +1,21 @@
 import { ExpressitError } from "../internal/ExpressitError.js"
-import type { ErrorToken, RawToken, TOKEN_TYPE, ValidToken } from "../types/ast.js"
-import { ERROR_CODES } from "../types/errors.js"
+import type { ErrorToken, RawToken, TokenType, ValidToken } from "../types/ast.js"
+import { PARSER_ERROR } from "../types/errors.js"
 
 export function createToken<
-	TType extends TOKEN_TYPE,
+	TType extends TokenType,
 >(raw: { type: TType } & RawToken<ValidToken>): ValidToken<TType>
 export function createToken(raw: RawToken<ErrorToken>): ErrorToken
 export function createToken<
 	TValid extends boolean = boolean,
 	TType extends
-		TValid extends true ? TOKEN_TYPE : never =
-		TValid extends true ? TOKEN_TYPE : never,
+		TValid extends true ? TokenType : never =
+		TValid extends true ? TokenType : never
 >(raw: RawToken<ValidToken> | RawToken<ErrorToken>): TValid extends true
 ? ValidToken<TType>
 : ErrorToken {
 	if (raw.start === undefined || raw.end === undefined) {
-		throw new ExpressitError(ERROR_CODES.PARSER_POSITION_ERROR, raw)
+		throw new ExpressitError(PARSER_ERROR.POSITION_ERROR, raw)
 	}
 	return {
 		...raw,

package/src/ast/error.ts

@@ -1,8 +1,8 @@
 import { createToken } from "./createToken.js"
 
-import { type ErrorToken,type TOKEN_TYPE } from "../types/ast.js"
+import { type ErrorToken,type TokenType } from "../types/ast.js"
 
-export function error<T extends TOKEN_TYPE>(pos: number, expected: T[]): ErrorToken {
+export function error<T extends TokenType>(pos: number, expected: T[]): ErrorToken {
 	if (pos === undefined) throw new Error("should never happen, passed undefined position for error token")
 	return createToken({ expected, start: pos, end: pos })
 }

package/src/ast/handlers.ts

@@ -7,28 +7,28 @@ import { createGroupNode } from "./createGroupNode.js"
 import { createToken } from "./createToken.js"
 import { createVariableNode } from "./createVariableNode.js"
 
-import { type AnyToken, type ArrayNode,AST_TYPE,type ConditionNode, type ErrorToken, type ExpressionNode,type FirstParam,type GroupNode, type Position, TOKEN_TYPE, type TokenBooleanTypes, type TokenDelimiterTypes, type TokenOperatorTypes, type TokenQuoteTypes, type ValidToken, type VariableNode } from "../types/ast.js"
+import { type AnyToken, type ArrayNode,AST_TYPE,type ConditionNode, type ErrorToken, type ExpressionNode,type FirstParam,type GroupNode, type Position, TOKEN_TYPE, type TokenBoolean, type TokenDelimiter, type TokenOperator, type TokenQuote, type TokenType, type ValidToken, type VariableNode } from "../types/ast.js"
 
 
 /* #region HELPERS */
-function error<T extends TOKEN_TYPE>(pos: number, expected: T[]): ErrorToken {
+function error<T extends TokenType>(pos: number, expected: T[]): ErrorToken {
 	if (pos === undefined) throw new Error("should never happen, passed undefined position for error token")
 	return createToken({ expected, start: pos, end: pos })
 }
 /* #regionend */
 
 /* #region TOKENS */
-const operators = <T extends TokenOperatorTypes>
+const operators = <T extends TokenOperator>
 (type: T) =>
 	(value: string, pos: Position): ValidToken<T> => createToken({ value, type, ...pos })
 
-const delimiters = <T extends TokenDelimiterTypes>
+const delimiters = <T extends TokenDelimiter>
 (type: T) =>
 	(value: string | undefined, pos: Position): ValidToken<T> | undefined =>
 		// check must be falsy, we want to return undefined when given ""
 		value ? createToken({ value, type, ...pos }) : undefined
 
-const maybeToken = <T extends TOKEN_TYPE> (type: T) => <TVal extends string | undefined> (value: TVal, pos: Position): TVal extends string ? ValidToken<T> : ErrorToken => {
+const maybeToken = <T extends TokenType> (type: T) => <TVal extends string | undefined> (value: TVal, pos: Position): TVal extends string ? ValidToken<T> : ErrorToken => {
 	if (value === undefined) {
 		return error(pos.end, [type]) as any
 	} else {
@@ -63,11 +63,11 @@ export const operator = {
 
 /* #region AST NODES */
 export function variable(
-	prefix: ValidToken<TOKEN_TYPE.VALUE> | null | undefined,
-	quoteL: AnyToken<TokenQuoteTypes> | null | undefined,
-	value: AnyToken<TOKEN_TYPE.VALUE> | null | undefined,
-	quoteR: AnyToken<TokenQuoteTypes> | null | undefined,
-	flags?: ValidToken<TOKEN_TYPE.VALUE>,
+	prefix: ValidToken<typeof TOKEN_TYPE.VALUE> | null | undefined,
+	quoteL: AnyToken<TokenQuote> | null | undefined,
+	value: AnyToken<typeof TOKEN_TYPE.VALUE> | null | undefined,
+	quoteR: AnyToken<TokenQuote> | null | undefined,
+	flags?: ValidToken<typeof TOKEN_TYPE.VALUE>,
 ): VariableNode {
 	const node: FirstParam<typeof createVariableNode> = {
 		prefix: prefix ?? undefined,
@@ -92,19 +92,19 @@ export function variable(
 
 
 export function condition(
-	not: ValidToken<TOKEN_TYPE.NOT> | null | undefined,
+	not: ValidToken<typeof TOKEN_TYPE.NOT> | null | undefined,
 	property: VariableNode | null | undefined,
 	{ propertyOperator, sepL, sepR }: {
 		propertyOperator?: ConditionNode["propertyOperator"] | null
-		sepL?: ValidToken<TOKEN_TYPE.OP_EXPANDED_SEP> | null
-		sepR?: ValidToken<TOKEN_TYPE.OP_EXPANDED_SEP> | null
+		sepL?: ValidToken<typeof TOKEN_TYPE.OP_EXPANDED_SEP> | null
+		sepR?: ValidToken<typeof TOKEN_TYPE.OP_EXPANDED_SEP> | null
 	} = {},
 	value?: VariableNode | GroupNode | ArrayNode | null,
 ): ConditionNode {
 	const start = (not?.start ?? property?.start ?? sepL?.start ?? propertyOperator?.start ?? sepR?.start ?? value?.start)!
 	const end = (value?.end ?? sepR?.end ?? propertyOperator?.end ?? sepL?.end ?? property?.end ?? not?.end)!
 	const node: FirstParam<typeof createConditionNode> = {
-		value: value ? value : error(end, [TOKEN_TYPE.VALUE]),
+		value: value ?? error(end, [TOKEN_TYPE.VALUE]),
 		start,
 		end,
 	}
@@ -130,7 +130,7 @@ export function condition(
 
 export function expression(
 	left: ConditionNode | GroupNode | null | undefined,
-	operator: ValidToken<TokenBooleanTypes> | null | undefined,
+	operator: ValidToken<TokenBoolean> | null | undefined,
 	right: ConditionNode | GroupNode | null | undefined,
 ): ExpressionNode {
 	return createExpressionNode({
@@ -143,11 +143,11 @@ export function expression(
 }
 
 export function group(
-	operator: ValidToken<TOKEN_TYPE.NOT> | null | undefined,
+	operator: ValidToken<typeof TOKEN_TYPE.NOT> | null | undefined,
 	prefix: ConditionNode | null | undefined,
-	parenL: ValidToken<TOKEN_TYPE.PARENL> | null | undefined,
+	parenL: ValidToken<typeof TOKEN_TYPE.PARENL> | null | undefined,
 	condition: GroupNode["expression"],
-	parenR: ValidToken<TOKEN_TYPE.PARENR> | null | undefined,
+	parenR: ValidToken<typeof TOKEN_TYPE.PARENR> | null | undefined,
 ): GroupNode {
 	return createGroupNode({
 		prefix: prefix ?? operator ?? undefined,
@@ -162,9 +162,9 @@ export function group(
 }
 
 export function array(
-	bracketL: ValidToken<TOKEN_TYPE.BRACKETL>,
+	bracketL: ValidToken<typeof TOKEN_TYPE.BRACKETL>,
 	values: VariableNode[],
-	bracketR: ValidToken<TOKEN_TYPE.BRACKETR> | null | undefined,
+	bracketR: ValidToken<typeof TOKEN_TYPE.BRACKETR> | null | undefined,
 ): ArrayNode {
 	return createArrayNode({
 		values,

package/src/examples/ParserWithSqlSupport.ts

@@ -1,4 +1,4 @@
-import { unreachable } from "@alanscodelog/utils/unreachable.js"
+import { unreachable } from "@alanscodelog/utils/unreachable"
 
 import { Parser } from "../Parser.js"
 import { AST_TYPE, type NormalizedCondition, type NormalizedExpression, type Position,TOKEN_TYPE } from "../types/ast.js"
@@ -29,7 +29,7 @@ export interface BaseOperatorDefinition {
 	/** How to compare the value when evualuating a condition. This is only used if using `evaluate`. */
 	valueComparer: (condition: any, contextValue: any) => boolean
 }
-export type BaseErrorTokenTypes =
+export type SqlParserError =
 	| "invalidKey"
 	| "unknownProperty"
 	| "unknownOperator"
@@ -53,11 +53,11 @@ export type BaseErrorTokenTypes =
  */
 export class ParserWithSqlSupport<TErrorToken extends
 	Position & {
-		type: BaseErrorTokenTypes
+		type: SqlParserError
 		message?: string
 	} =
 	Position & {
-		type: BaseErrorTokenTypes
+		type: SqlParserError
 		message?: string
 	},
 	TPropertyDefinition extends BasePropertyDefinition = BasePropertyDefinition,
@@ -70,9 +70,13 @@ export class ParserWithSqlSupport<TErrorToken extends
 
 	operatorMap: Record<string, string>
 
+	propertyDefinitions: TPropertyDefinitions
+
+	operatorDefinitions: TOperatorDefinitions
+
 	constructor(
-		public propertyDefinitions: TPropertyDefinitions,
-		public operatorDefinitions: TOperatorDefinitions,
+		propertyDefinitions: TPropertyDefinitions,
+		operatorDefinitions: TOperatorDefinitions,
 		{ sqlEscapeValue }: { sqlEscapeValue: TSqlEscapeValue }
 	) {
 		const operators = []
@@ -229,6 +233,8 @@ export class ParserWithSqlSupport<TErrorToken extends
 				return { value: finalValue, operator: finalOperator, negate: isNegated }
 			},
 		})
+		this.propertyDefinitions = propertyDefinitions
+		this.operatorDefinitions = operatorDefinitions
 		this.operatorMap = operatorMap
 		this.sqlEscapeValue = sqlEscapeValue
 	}

package/src/internal/ExpressitError.ts

@@ -1,14 +1,14 @@
-import { crop } from "@alanscodelog/utils/crop.js"
-import { indent } from "@alanscodelog/utils/indent.js"
-import { pretty } from "@alanscodelog/utils/pretty.js"
+import { crop } from "@alanscodelog/utils/crop"
+import { indent } from "@alanscodelog/utils/indent"
+import { pretty } from "@alanscodelog/utils/pretty"
 import type { Keys } from "@alanscodelog/utils/types"
 
-import packageJson from "../../package.json" assert { type: "json" }
+import packageJson from "../../package.json" with { type: "json" }
 const { version, repository } = packageJson
-import type { ERROR_CODES, ErrorInfo } from "../types/errors.js"
+import type { ErrorInfo, ParserError } from "../types/errors.js"
 
 /** @internal */
-export class ExpressitError<T extends ERROR_CODES> extends Error {
+export class ExpressitError<T extends ParserError> extends Error {
 	version: string = version
 
 	repo: string = repository

package/src/internal/checkParserOpts.ts

@@ -1,11 +1,11 @@
-import { isBlank } from "@alanscodelog/utils/isBlank.js"
-import { pushIfNotIn } from "@alanscodelog/utils/pushIfNotIn.js"
+import { isBlank } from "@alanscodelog/utils/isBlank"
+import { pushIfNotIn } from "@alanscodelog/utils/pushIfNotIn"
 
 import { ExpressitError } from "./ExpressitError.js"
 
 import { defaultConditionNormalizer } from "../defaults/defaultConditionNormalizer.js"
 import { defaultValueComparer } from "../defaults/defaultValueComparer.js"
-import { ERROR_CODES } from "../types/errors.js"
+import { PARSER_ERROR } from "../types/errors.js"
 import type { FullParserOptions, ParserOptions } from "../types/parser.js"
 
 /** @internal */
@@ -27,7 +27,7 @@ export function checkParserOpts<T>(opts: FullParserOptions<T>, evaluatorChecks:
 		/* #region Blank Operator Checks */
 		if (opts.expandedPropertySeparator && isBlank(opts.expandedPropertySeparator)) {
 			throw new ExpressitError(
-				ERROR_CODES.PARSER_CONFLICTING_OPTIONS_ERROR,
+				PARSER_ERROR.CONFLICTING_OPTIONS_ERROR,
 				{ prohibited: [""], invalid: opts.expandedPropertySeparator },
 			`expandedPropertySeparator cannot be blank`,
 			)
@@ -35,7 +35,7 @@ export function checkParserOpts<T>(opts: FullParserOptions<T>, evaluatorChecks:
 		const customInvalid = opts.customPropertyOperators?.find(_ => isBlank(_))
 		if (customInvalid !== undefined) {
 			throw new ExpressitError(
-				ERROR_CODES.PARSER_CONFLICTING_OPTIONS_ERROR,
+				PARSER_ERROR.CONFLICTING_OPTIONS_ERROR,
 				{ prohibited: [""], invalid: customInvalid },
 			`customPropertyOperators cannot contain blank entries`,
 			)
@@ -43,7 +43,7 @@ export function checkParserOpts<T>(opts: FullParserOptions<T>, evaluatorChecks:
 		const prefixInvalid = opts.prefixableStrings?.find(_ => isBlank(_))
 		if (prefixInvalid !== undefined) {
 			throw new ExpressitError(
-				ERROR_CODES.PARSER_CONFLICTING_OPTIONS_ERROR,
+				PARSER_ERROR.CONFLICTING_OPTIONS_ERROR,
 				{ prohibited: [""], invalid: prefixInvalid },
 			`prefixableStrings cannot contain blank entries`,
 			)
@@ -54,7 +54,7 @@ export function checkParserOpts<T>(opts: FullParserOptions<T>, evaluatorChecks:
 				?.value
 			if (invalid !== undefined) {
 				throw new ExpressitError(
-					ERROR_CODES.PARSER_CONFLICTING_OPTIONS_ERROR,
+					PARSER_ERROR.CONFLICTING_OPTIONS_ERROR,
 					{ prohibited: [""], invalid },
 				`keywords.${key} cannot contain entries with blank values`,
 				)
@@ -77,7 +77,7 @@ export function checkParserOpts<T>(opts: FullParserOptions<T>, evaluatorChecks:
 		const invalidPrefixableString = opts.prefixableStrings?.find(val => all.includes(val))
 		if (invalidPrefixableString) {
 			throw new ExpressitError(
-				ERROR_CODES.PARSER_CONFLICTING_OPTIONS_ERROR,
+				PARSER_ERROR.CONFLICTING_OPTIONS_ERROR,
 				{ prohibited: all, invalid: invalidPrefixableString },
 			`prefixableStrings ${messageInvalidAny} "${invalidPrefixableString}"`,
 			)
@@ -87,7 +87,7 @@ export function checkParserOpts<T>(opts: FullParserOptions<T>, evaluatorChecks:
 			.find(_ => _ === opts.expandedPropertySeparator as any)
 		if (invalidExpandedPropertySeparator) {
 			throw new ExpressitError(
-				ERROR_CODES.PARSER_CONFLICTING_OPTIONS_ERROR,
+				PARSER_ERROR.CONFLICTING_OPTIONS_ERROR,
 				{ prohibited: allKeywords, invalid: invalidExpandedPropertySeparator },
 			`expandedPropertySeparator ${messageInvalidBool} "${invalidExpandedPropertySeparator}"`,
 			)
@@ -98,7 +98,7 @@ export function checkParserOpts<T>(opts: FullParserOptions<T>, evaluatorChecks:
 		: undefined
 		if (invalidCustomPropertyOperator) {
 			throw new ExpressitError(
-				ERROR_CODES.PARSER_CONFLICTING_OPTIONS_ERROR,
+				PARSER_ERROR.CONFLICTING_OPTIONS_ERROR,
 				{ prohibited: keywords, invalid: invalidCustomPropertyOperator },
 			`customPropertyOperator ${messageInvalidBool} "${invalidCustomPropertyOperator}"`,
 			)
@@ -115,7 +115,7 @@ export function checkParserOpts<T>(opts: FullParserOptions<T>, evaluatorChecks:
 
 		if (requireCustomNormalizer.length > 0 && opts.conditionNormalizer === defaultConditionNormalizer) {
 			throw new ExpressitError(
-				ERROR_CODES.PARSER_OPTION_REQUIRED_ERROR,
+				PARSER_ERROR.OPTION_REQUIRED_ERROR,
 				{ options: requireCustomNormalizer, requires: "conditionNormalizer" },
 				`A custom conditionNormalizer function must be specified when using the following options: ${requireCustomNormalizer.join(", ")}`,
 			)
@@ -126,7 +126,7 @@ export function checkParserOpts<T>(opts: FullParserOptions<T>, evaluatorChecks:
 
 		if (requireCustomComparer.length > 0 && opts.valueComparer === defaultValueComparer) {
 			throw new ExpressitError(
-				ERROR_CODES.PARSER_OPTION_REQUIRED_ERROR,
+				PARSER_ERROR.OPTION_REQUIRED_ERROR,
 				{ options: requireCustomComparer, requires: "valueComparer" },
 					`A custom valueComparer function must be specified when using the following options: ${requireCustomComparer.join(", ")}`,
 			)
@@ -135,7 +135,7 @@ export function checkParserOpts<T>(opts: FullParserOptions<T>, evaluatorChecks:
 	if (validatorChecks) {
 		if (opts.valueValidator === undefined) {
 			throw new ExpressitError(
-				ERROR_CODES.PARSER_OPTION_REQUIRED_ERROR,
+				PARSER_ERROR.OPTION_REQUIRED_ERROR,
 				{ requires: "valueValidator" },
 				`A custom valueValidator function must be specified when using the validate method.`,
 			)

package/src/internal/escapeVariableOrPrefix.ts

@@ -1,4 +1,4 @@
-import { multisplice } from "@alanscodelog/utils/multisplice.js"
+import { multisplice } from "@alanscodelog/utils/multisplice"
 
 export function escapeVariableOrPrefix(variable: string, preferredQuote: string): string {
 	let doQuote = false