@witchcraft/expressit 0.2.2 → 0.3.0

package/src/types/autocomplete.ts

@@ -1,3 +1,6 @@
+import { type EnumLike } from "@alanscodelog/utils"
+import { enumFromArray } from "@alanscodelog/utils/enumFromArray.js"
+
 import type { AnyToken, Position, ValidToken } from "./ast.js"
 
 
@@ -82,35 +85,36 @@ export type CursorInfo = {
 	}
 }
 
-export enum SUGGESTION_TYPE {
-	// can ignore whitespace requirement if replacing with quoted
-	VARIABLE = "VARIABLE",
-	ARRAY_VALUE = "ARRAY_VALUE",
-	VALUE = "VALUE",
-	PREFIX = "PREFIX",
-	BOOLEAN_WORD_OP = "BOOLEAN_WORD_OP",
-	BOOLEAN_SYMBOL_OP = "BOOLEAN_SYMBOL_OP",
-	BACKTICK = "BACKTICK",
-	DOUBLEQUOTE = "DOUBLEQUOTE",
-	SINGLEQUOTE = "SINGLEQUOTE",
-	PARENL = "PARENL",
-	PARENR = "PARENR",
-	PROPERTY = "PROPERTY",
-	EXPANDED_PROPERTY_OPERATOR = "EXPANDED_PROPERTY_OPERATOR",
-	CUSTOM_PROPERTY_OPERATOR = "CUSTOM_PROPERTY_OPERATOR",
-	PROPERTY_SEP = "PROPERTY_SEP",
-	BRAKCETR = "BRAKCETR",
-	REGEX = "REGEX",
-	REGEX_FLAGS = "REGEX_FLAGS",
+export const SUGGESTION_TYPE = enumFromArray([
+	"VARIABLE",
+	"ARRAY_VALUE",
+	"VALUE",
+	"PREFIX",
+	"BOOLEAN_WORD_OP",
+	"BOOLEAN_SYMBOL_OP",
+	"BACKTICK",
+	"DOUBLEQUOTE",
+	"SINGLEQUOTE",
+	"PARENL",
+	"PARENR",
+	"PROPERTY",
+	"EXPANDED_PROPERTY_OPERATOR",
+	"CUSTOM_PROPERTY_OPERATOR",
+	"PROPERTY_SEP",
+	"BRAKCETR",
+	"REGEX",
+	"REGEX_FLAGS",
 	/** This is not an oversight, I haven't figured out a fast way to detect left bracket errors. */
 	// BRAKCETL = "BRAKCETL",
-}
+])
+
+export type SuggestionType = EnumLike<typeof SUGGESTION_TYPE>
 
 /**
  * A suggestion entry that describes a type of suggestion.
  */
 export type Suggestion = {
-	type: SUGGESTION_TYPE
+	type: SuggestionType
 	/** The range the suggestion should replace / be inserted at. */
 	range: Position
 	/** {@link CursorInfo} */

package/src/types/errors.ts

@@ -1,29 +1,34 @@
+import { type EnumLike } from "@alanscodelog/utils"
+import { enumFromArray } from "@alanscodelog/utils/enumFromArray.js"
+
 import type { ParserOptions } from "./parser.js"
 
 
-export enum ERROR_CODES {
-	PARSER_POSITION_ERROR = "PARSER.POSITION",
-	PARSER_CONFLICTING_OPTIONS_ERROR = "PARSER.OPTIONS.CONFLICTING",
-	PARSER_OPTION_REQUIRED_ERROR = "PARSER.OPTIONS.CUSTOM_REQUIRED",
-}
+export const PARSER_ERROR = enumFromArray([
+	"POSITION_ERROR",
+	"CONFLICTING_OPTIONS_ERROR",
+	"OPTION_REQUIRED_ERROR",
+], "PARSER.")
+
+export type ParserError = EnumLike<typeof PARSER_ERROR>
 
 
-export type ErrorInfo<T extends ERROR_CODES> =
-	T extends ERROR_CODES
-	? ERROR_Info[T]
+export type ErrorInfo<T extends ParserError> =
+	T extends ParserError
+	? ErrorCodesInfo[T]
 	: never
 
-// eslint-disable-next-line @typescript-eslint/naming-convention
-export type ERROR_Info = {
-	[ERROR_CODES.PARSER_POSITION_ERROR]: {
+ 
+export type ErrorCodesInfo = {
+	[PARSER_ERROR.POSITION_ERROR]: {
 		start?: number
 		end?: number
 	}
-	[ERROR_CODES.PARSER_CONFLICTING_OPTIONS_ERROR]: {
+	[PARSER_ERROR.CONFLICTING_OPTIONS_ERROR]: {
 		prohibited: string[]
 		invalid: string
 	}
-	[ERROR_CODES.PARSER_OPTION_REQUIRED_ERROR]: {
+	[PARSER_ERROR.OPTION_REQUIRED_ERROR]: {
 		options?: (keyof ParserOptions)[]
 		requires: keyof ParserOptions
 	}

package/src/types/parser.ts

@@ -443,9 +443,9 @@ export type ValueQuery
 /** {@link ParserOptions}["valueValidator"] */
 export type ValidationQuery = Omit<ValueQuery, "value" | "operator" | "prefix" | "regexFlags" | "property"> & {
 	value?: VariableNode | ArrayNode
-	operator?: ValidToken<TOKEN_TYPE.VALUE | TOKEN_TYPE.OP_CUSTOM>
-	prefix?: ValidToken<TOKEN_TYPE.VALUE>
-	regexFlags?: ValidToken<TOKEN_TYPE.VALUE>
+	operator?: ValidToken<typeof TOKEN_TYPE.VALUE | typeof TOKEN_TYPE.OP_CUSTOM>
+	prefix?: ValidToken<typeof TOKEN_TYPE.VALUE>
+	regexFlags?: ValidToken<typeof TOKEN_TYPE.VALUE>
 	property: VariableNode[]
 	/** The property as would be passed to the {@link ParserOptions}["valueComparer"] function (i.e. joined as a string using the {@link ParseOptions}["prefixApplier"] ) */
 	propertyName?: string

package/src/utils/getOppositeDelimiter.ts

@@ -6,7 +6,7 @@ import { isDelimiter } from "./isDelimiter.js"
 import { isParen } from "./isParen.js"
 import { isQuote } from "./isQuote.js"
 
-import { type AnyToken, type ArrayNode, type ConditionNode,type GroupNode, TOKEN_TYPE, type TokenDelimiterTypes, type VariableNode } from "../types/ast.js"
+import { type AnyToken, type ArrayNode, type ConditionNode,type GroupNode, TOKEN_TYPE, type TokenDelimiter, type VariableNode } 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).
@@ -14,7 +14,7 @@ import { type AnyToken, type ArrayNode, type ConditionNode,type GroupNode, TOKEN
 export function getOppositeDelimiter(
 	token: AnyToken,
 	parentsMap: ReturnType<typeof generateParentsMap>
-): AnyToken<TokenDelimiterTypes> | undefined {
+): AnyToken<TokenDelimiter> | undefined {
 	const parent = parentsMap.get(token)
 	if (!isDelimiter(token)) throw new Error("Token is not a delimiter type.")
 	if (isParen(token)) {

package/src/utils/getSurroundingErrors.ts

@@ -43,10 +43,10 @@ export function getSurroundingErrors(tokens: AnyToken[], token: CursorInfo): Err
 	}
 
 	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 aIsQuote = ([TOKEN_TYPE.DOUBLEQUOTE, TOKEN_TYPE.BACKTICK, TOKEN_TYPE.SINGLEQUOTE] as string[]).includes(a.expected[0])
+		const bIsQuote = ([TOKEN_TYPE.DOUBLEQUOTE, TOKEN_TYPE.BACKTICK, TOKEN_TYPE.SINGLEQUOTE]as string[]).includes(b.expected[0])
+		const aIsParen = ([TOKEN_TYPE.PARENR, TOKEN_TYPE.PARENL] as string[]).includes(a.expected[0])
+		const bIsParen = ([TOKEN_TYPE.PARENR, TOKEN_TYPE.PARENL] as string[]).includes(b.expected[0])
 		const aCloseness = Math.abs(i - tokens.indexOf(a))
 		const bCloseness = Math.abs(i - tokens.indexOf(b))
 		const closenessComparison = aCloseness - bCloseness

package/src/utils/isDelimiter.ts

@@ -1,9 +1,9 @@
-import { type AnyToken, TOKEN_TYPE, type TokenDelimiterTypes } from "../types/ast.js"
+import { type AnyToken, TOKEN_TYPE, type TokenDelimiter } 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> {
+export function isDelimiter(token?: AnyToken): token is AnyToken<TokenDelimiter> {
 	return ([
 		TOKEN_TYPE.BACKTICK,
 		TOKEN_TYPE.DOUBLEQUOTE,
@@ -14,5 +14,5 @@ export function isDelimiter(token?: AnyToken): token is AnyToken<TokenDelimiterT
 		TOKEN_TYPE.BRACKETR,
 		TOKEN_TYPE.OP_EXPANDED_SEP,
 		TOKEN_TYPE.REGEX,
-	] as TokenDelimiterTypes[]).includes(token?.type as TokenDelimiterTypes)
+	] as TokenDelimiter[]).includes(token?.type as TokenDelimiter)
 }

package/src/utils/isParen.ts

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

package/src/utils/isQuote.ts

@@ -1,6 +1,6 @@
-import { type AnyToken, TOKEN_TYPE, type TokenQuoteTypes } from "../types/ast.js"
+import { type AnyToken, TOKEN_TYPE, type TokenQuote } 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> {
+export function isQuote(token?: AnyToken): token is AnyToken<TokenQuote> {
 	return ([TOKEN_TYPE.BACKTICK, TOKEN_TYPE.DOUBLEQUOTE, TOKEN_TYPE.SINGLEQUOTE, TOKEN_TYPE.REGEX] as any[]).includes(token?.type)
 }