@witchcraft/expressit 0.1.2 → 0.2.0

package/src/ast/builders/array.ts

@@ -1,10 +1,7 @@
-import type { Mutable } from "@alanscodelog/utils/types"
-
 import { token } from "./token.js"
 
-import { AST_TYPE, type Position, TOKEN_TYPE } from "../../types/ast.js"
-import { ArrayNode } from "../classes/ArrayNode.js"
-import type { VariableNode } from "../classes/VariableNode.js"
+import { type ArrayNode, type FirstParam,type Position, TOKEN_TYPE, type VariableNode } from "../../types/ast.js"
+import { createArrayNode } from "../createArrayNode.js"
 
 
 export function array(
@@ -13,8 +10,7 @@ export function array(
 	parenLeftPos?: Position,
 	parenRightPos?: Position,
 ): ArrayNode {
-	const node: Mutable<Partial<ArrayNode>> = {
-		type: AST_TYPE.ARRAY,
+	const node: Partial<FirstParam<typeof createArrayNode>> = {
 		values,
 	}
 
@@ -40,6 +36,5 @@ export function array(
 	node.start = node.bracket!.left?.start ?? start ?? node.bracket?.right.start
 	node.end = node.bracket?.right?.end ?? end ?? node.bracket!.left.end
 
-	const instance = new ArrayNode(node as any)
-	return instance
+	return createArrayNode(node as any)
 }

package/src/ast/builders/condition.ts

@@ -1,19 +1,14 @@
 import { pos } from "./pos.js"
 
-import { type AnyToken, type Position, type TOKEN_TYPE } from "../../types/ast.js"
-import type { ArrayNode } from "../classes/ArrayNode.js"
-import { ConditionNode } from "../classes/ConditionNode.js"
-import type { ErrorToken } from "../classes/ErrorToken.js"
-import type { GroupNode } from "../classes/GroupNode.js"
-import type { ValidToken } from "../classes/ValidToken.js"
-import type { VariableNode } from "../classes/VariableNode.js"
+import { type AnyToken, type ArrayNode, type ConditionNode, type ErrorToken, type FirstParam, type GroupNode, type Position, type TOKEN_TYPE, type ValidToken, type VariableNode } from "../../types/ast.js"
+import { createConditionNode } from "../createConditionNode.js"
 
 /**
- * Creates a @see ConditionNode
+ * Creates a {@link ConditionNode}
  *
- * @param variable An existing @see VariableNode
+ * @param variable An existing {@link VariableNode}
  *
- * @param not Defaults to plain true condition. To negate it you must pass an existing "not" operator @see ValidToken which will be set as the node's operator and set the node's value to false.
+ * @param not Defaults to plain true condition. To negate it you must pass an existing "not" operator {@link ValidToken} which will be set as the node's operator and set the node's value to false.
  *
  * @param property Set the property for a property operator. A property operator must be passed if this is passed.
  * @param propertyOperator Set the operator for a property condition. A property must have been passed. The property operator must be a valid token. There is no case where it would not be. If using an operator that is the same as a separator, if used as an operator, should be set as an operator.
@@ -25,9 +20,9 @@ export function condition(
 	| VariableNode
 	| GroupNode
 	| ArrayNode
-	| ErrorToken<TOKEN_TYPE.VALUE>,
+	| ErrorToken,
 	not: true | ValidToken<TOKEN_TYPE.NOT> = true,
-	property?: VariableNode | ErrorToken<TOKEN_TYPE.VALUE>,
+	property?: VariableNode | ErrorToken,
 	propertyOperator?: AnyToken<TOKEN_TYPE.OP_CUSTOM | TOKEN_TYPE.VALUE>,
 	{ right, left }: Partial<Record<"right" | "left", ValidToken<TOKEN_TYPE.OP_EXPANDED_SEP>>> = { },
 ): ConditionNode {
@@ -35,7 +30,7 @@ export function condition(
 	const notStart = not === true ? undefined : not.start
 	position.start = notStart ?? property?.start ?? propertyOperator?.start ?? position.start
 
-	const node: Partial<ConstructorParameters<typeof ConditionNode>[0]> = {
+	const node: FirstParam<typeof createConditionNode> = {
 		property,
 		value,
 		propertyOperator,
@@ -50,7 +45,7 @@ export function condition(
 		if (right) node.sep.right = right
 		if (left) node.sep.left = left
 	}
-	const instance = new ConditionNode(node as any)
-	return instance
+
+	return createConditionNode(node)
 }
 

package/src/ast/builders/delim.ts

@@ -3,7 +3,7 @@ import { type } from "./type.js"
 import { type ExtractTokenType, TOKEN_TYPE } from "../../types/ast.js"
 
 /**
- * Faster way, more intuitive way to generate the options for matching delimiters (e.g. quotes and parens) for functions like @see variable and @see group .
+ * Faster way, more intuitive way to generate the options for matching delimiters (e.g. quotes and parens) for functions like {@link variable} and {@link group} .
  */
 
 export function delim<

package/src/ast/builders/error.ts

@@ -1,16 +1,16 @@
 import { type } from "./type.js"
 
-import { TOKEN_TYPE } from "../../types/ast.js"
-import { ErrorToken } from "../classes/ErrorToken.js"
+import { type ErrorToken,TOKEN_TYPE } from "../../types/ast.js"
+import { createToken } from "../createToken.js"
 
 
 /**
  * Creates an error token.
  *
- * @param expected Can be passed an array of @see ValidToken_TYPE or strings, in which case it will use @see type internally. So instead of `[TOKEN_TYPE.VALUE]` we can do `[""]` and instead of `[TOKEN_TYPE.PARENR]` we can do `[")"]`.
+ * @param expected Can be passed an array of {@link ValidToken_TYPE} or strings, in which case it will use {@link type} internally. So instead of `[TOKEN_TYPE.VALUE]` we can do `[""]` and instead of `[TOKEN_TYPE.PARENR]` we can do `[")"]`.
  */
-export function error<T extends TOKEN_TYPE>(pos: number, expected: T[]): ErrorToken<T>
-export function error<T extends TOKEN_TYPE>(pos: number, expected_: T[]): ErrorToken<T> {
+export function error<T extends TOKEN_TYPE>(pos: number, expected: T[]): ErrorToken
+export function error<T extends TOKEN_TYPE>(pos: number, expected_: T[]): ErrorToken {
 	const expected = expected_.map(item => {
 		if (TOKEN_TYPE[item as keyof typeof TOKEN_TYPE] === undefined) {
 			return type(item)
@@ -18,5 +18,9 @@ export function error<T extends TOKEN_TYPE>(pos: number, expected_: T[]): ErrorT
 			return item
 		}
 	}) as T []
-	return new ErrorToken({ expected, start: pos, end: pos })
+	return createToken({
+		expected,
+		start: pos,
+		end: pos
+	})
 }

package/src/ast/builders/expression.ts

@@ -1,34 +1,31 @@
 import { pos } from "./pos.js"
 import { token } from "./token.js"
 
-import { type AnyToken, type Position, TOKEN_TYPE, type TokenBooleanTypes } from "../../types/ast.js"
-import type { ConditionNode } from "../classes/ConditionNode.js"
-import type { ErrorToken } from "../classes/ErrorToken.js"
-import { ExpressionNode } from "../classes/ExpressionNode.js"
-import type { GroupNode } from "../classes/GroupNode.js"
+import { type AnyToken, type ConditionNode, type ErrorToken, type ExpressionNode,type GroupNode, type Position, TOKEN_TYPE, type TokenBooleanTypes } from "../../types/ast.js"
+import { createExpressionNode } from "../createExpressionNode.js"
 
 
 /**
- * Creates an @see ExpressionNode, can be passed nothing for any of the tokens to automatically create error tokens.
+ * Creates an {@link ExpressionNode}, can be passed nothing for any of the tokens to automatically create error tokens.
  *
  * Also automatically sets the correct start/end positions from valid tokens (e.g. for start, searching left to right for a valid token and vice versa) assuming at least one is defined.
  */
 export function expression(
 	left:
-	ConditionNode |
-	ExpressionNode |
-	GroupNode |
-	ErrorToken<TOKEN_TYPE.VALUE> |
-	undefined,
+		ConditionNode |
+		ExpressionNode |
+		GroupNode |
+		ErrorToken |
+		undefined,
 	operator:
-	AnyToken<TokenBooleanTypes> |
-	undefined,
+		AnyToken<TokenBooleanTypes> |
+		undefined,
 	right:
-	ConditionNode |
-	ExpressionNode |
-	GroupNode |
-	ErrorToken<TOKEN_TYPE.VALUE> |
-	undefined,
+		ConditionNode |
+		ExpressionNode |
+		GroupNode |
+		ErrorToken |
+		undefined,
 ): ExpressionNode {
 	const start =
 		left?.start ??
@@ -54,13 +51,10 @@ export function expression(
 		right = token(TOKEN_TYPE.VALUE, undefined, { start: op.end })
 	}
 
-	const node: ConstructorParameters<typeof ExpressionNode>[0] = {
+	return createExpressionNode({
 		left,
 		operator: op,
 		right,
 		...position,
-	}
-
-	const instance = new ExpressionNode(node)
-	return instance
+	})
 }

package/src/ast/builders/group.ts

@@ -1,18 +1,14 @@
 import { token } from "./token.js"
 
-import { type Position, TOKEN_TYPE } from "../../types/ast.js"
-import type { ConditionNode } from "../classes/ConditionNode.js"
-import type { ErrorToken } from "../classes/ErrorToken.js"
-import type { ExpressionNode } from "../classes/ExpressionNode.js"
-import { GroupNode } from "../classes/GroupNode.js"
-import type { ValidToken } from "../classes/ValidToken.js"
+import { type ConditionNode, type ErrorToken, type ExpressionNode, type FirstParam,type GroupNode, type Position, TOKEN_TYPE, type ValidToken } from "../../types/ast.js"
+import { createGroupNode } from "../createGroupNode.js"
 
 /**
  * Creates a group.
  *
  * Automatically creates error tokens if missing condition or parens (not prefix because it is optional). Will look at the position of prefix if available.
  *
- * @param paren Use to add parens to group, usually by using @see delim . If either `right` or `left` are false or undefined, error tokens will be created. Unlike @see variable, if undefined is passed for parens, parens are created by default.
+ * @param paren Use to add parens to group, usually by using {@link delim} . If either `right` or `left` are false or undefined, error tokens will be created. Unlike {@link variable}, if undefined is passed for parens, parens are created by default.
  *
  * The positions of the parens can be adjusted with the last two parameters by passing positions.
  */
@@ -27,7 +23,7 @@ export function group(
 	| ConditionNode
 	| ExpressionNode
 	| GroupNode
-	| ErrorToken<TOKEN_TYPE.VALUE>
+	| ErrorToken
 	| undefined,
 
 	paren: { left?: boolean, right?: boolean } = { right: true, left: true },
@@ -38,7 +34,8 @@ export function group(
 		expression = token(TOKEN_TYPE.VALUE, undefined, prefix?.end !== undefined ? { start: prefix.end } : undefined)
 	}
 
-	const node: Partial<ConstructorParameters<typeof GroupNode>[0]> = {
+	const node: Partial<FirstParam<typeof createGroupNode>> = {
+		prefix: undefined,
 		expression,
 	}
 	if (prefix) {
@@ -74,6 +71,5 @@ export function group(
 	node.start = node.prefix?.start ?? node.paren?.left?.start ?? node.expression?.start ?? node.paren?.right.start
 	node.end = node.paren?.right?.end ?? node.expression?.end ?? node.paren?.left.end ?? node.prefix?.end
 
-	const instance = new GroupNode(node as any)
-	return instance
+	return createGroupNode(node as any)
 }

package/src/ast/builders/pos.ts

@@ -1,7 +1,6 @@
 import { isFullPos } from "./isFullPos.js"
 
-import type { AnyToken, AST_TYPE, EmptyObj, Position, TOKEN_TYPE } from "../../types/ast.js"
-import type { Node } from "../classes/Node.js"
+import type { AnyToken, AST_TYPE, EmptyObj, Node, Position, TOKEN_TYPE } from "../../types/ast.js"
 
 /**
  * Can either:
@@ -20,7 +19,7 @@ export function pos<TItem extends Position | Partial<Position> | EmptyObj>(
 	item: TItem,
 	opts?: undefined | { fill: false }
 ):
-	// not sure why this needs the AnyToken check, prob something to do with using classes
+	// not sure why this needs the AnyToken check
 	TItem extends Position
 	? Position
 	: TItem extends AnyToken<TOKEN_TYPE> | Position | EmptyObj

package/src/ast/builders/token.ts

@@ -2,13 +2,12 @@ import { isArray } from "@alanscodelog/utils/isArray.js"
 
 import { pos } from "./pos.js"
 
-import type { AnyToken, EmptyObj, Position, TOKEN_TYPE } from "../../types/ast.js"
-import { ErrorToken } from "../classes/ErrorToken.js"
-import { ValidToken } from "../classes/ValidToken.js"
+import type { AnyToken, EmptyObj, ErrorToken, Position, TOKEN_TYPE, ValidToken } from "../../types/ast.js"
+import { createToken } from "../createToken.js"
 
 
 /**
- * Creates a @see ValidToken or of the given type with the given value. If no value is given, creates an @see ErrorToken instead.
+ * Creates a {@link ValidToken} or of the given type with the given value. If no value is given, creates an {@link ErrorToken} instead.
  *
  * Can be passed multiple types when creating an error token to set the expected field.
  *
@@ -23,20 +22,20 @@ export function token<
 	value: TValue,
 	position: Position | Partial<Position> | EmptyObj = {},
 ): TValue extends undefined
-	? ErrorToken<TType>
+	? ErrorToken
 	: ValidToken<TType> {
 	position = pos(position, { fill: true })
 	// eslint-disable-next-line @typescript-eslint/no-shadow
 	let token: AnyToken<TType>
 	if (value !== undefined) {
-		token = new ValidToken<TType>({
+		token = createToken({
 			type: type as TType,
 			value,
 			start: position.start!,
 			end: position.end!,
 		})
 	} else {
-		token = new ErrorToken<TType>({
+		token = createToken({
 			expected: (isArray(type) ? type : [type]) as TType[],
 			start: position.start!,
 			end: position.end!,

package/src/ast/builders/type.ts

@@ -1,6 +1,6 @@
 import { type ExtractTokenType, TOKEN_TYPE } from "../../types/ast.js"
 /**
- * Given a the string value of an operator or single delimiter token, returns the corresponding @see ValidToken_TYPE .
+ * Given a the string value of an operator or single delimiter token, returns the corresponding {@link ValidToken_TYPE} .
  */
 export function type<T extends string>(
 	operatorSymbol: T,

package/src/ast/builders/variable.ts

@@ -1,15 +1,14 @@
 import { pos } from "./pos.js"
 import { token } from "./token.js"
 
-import { type AnyToken, type EmptyObj, type Position, TOKEN_TYPE, type TokenQuoteTypes } from "../../types/ast.js"
-import type { ValidToken } from "../classes/ValidToken.js"
-import { VariableNode } from "../classes/VariableNode.js"
+import { type AnyToken, type EmptyObj,type FirstParam, type Position, TOKEN_TYPE, type TokenQuoteTypes, type ValidToken, type VariableNode } from "../../types/ast.js"
+import { createVariableNode } from "../createVariableNode.js"
 
 
 /**
- * Creates an @see VariableNode .
+ * Creates an {@link VariableNode} .
  *
- * @param quote Use to add quotes to the variable, usually by using @see delim . If false or undefined, no quotes are added. Otherwise at least `type` must be passed.  If one side is defined but not the other, error tokens will be created with the given type.
+ * @param quote Use to add quotes to the variable, usually by using {@link delim} . If false or undefined, no quotes are added. Otherwise at least `type` must be passed.  If one side is defined but not the other, error tokens will be created with the given type.
  *
  * @param position Refers to position of the value (in case it needs to be created) not the node. Quote positions are automatically calculated from this if used. If value is already a token, there's no need to pass a position, it can be extracted from the token.
  */
@@ -26,7 +25,7 @@ export function variable(
 
 	position = pos(value)
 
-	const node: Partial<ConstructorParameters<typeof VariableNode>[0]> = {
+	const node: Partial<FirstParam<typeof createVariableNode>> = {
 		value,
 		prefix,
 	}
@@ -74,8 +73,7 @@ export function variable(
 		node.value?.end ??
 		node.quote?.left.end
 
-	const instance = new VariableNode(node as any)
-	return instance
+	return createVariableNode(node as any)
 }
 
 function quoteFromType(type: TokenQuoteTypes | undefined): string {

package/src/ast/createArrayNode.ts

@@ -0,0 +1,17 @@
+import { type ArrayNode, AST_TYPE, type RawNode } from "../types/ast.js"
+
+
+export function createArrayNode<TValid extends boolean = boolean>(
+	raw: RawNode<ArrayNode<TValid>>
+): ArrayNode<TValid> {
+	return {
+		type: AST_TYPE.ARRAY,
+		isNode: true,
+		valid: (
+			raw.values.every(val => val.valid) &&
+			raw.bracket.left.valid &&
+			raw.bracket.right.valid
+		) as TValid,
+		...raw
+	}
+}

package/src/ast/createConditionNode.ts

@@ -0,0 +1,58 @@
+import { AST_TYPE, type ConditionNode, type TOKEN_TYPE, type ValidToken } from "../types/ast.js"
+import { isNode } from "../utils/isNode.js"
+
+
+export function createConditionNode<
+	TValid extends boolean = boolean,
+	TOperator extends
+		ValidToken<TOKEN_TYPE.NOT> | undefined =
+		ValidToken<TOKEN_TYPE.NOT> | undefined,
+>(raw: {
+	operator?: TOperator
+	property?: ConditionNode<TValid>["property"]
+	propertyOperator?: ConditionNode<TValid>["propertyOperator"]
+	sep?: ConditionNode<TValid>["sep"]
+	value: ConditionNode<TValid>["value"]
+	start: number
+	end: number
+}
+): ConditionNode<TValid> {
+	const valid = (
+		(
+			raw.operator === undefined
+			|| raw.operator?.valid
+		)
+		&& isNode(raw.value)
+		&& raw.value.valid
+	)
+	&& (
+		(
+			raw.property === undefined &&
+			raw.propertyOperator === undefined &&
+			raw.sep === undefined
+		) || (
+			raw.property !== undefined
+			&& "type" in raw.property
+			&& raw.property.type === AST_TYPE.VARIABLE
+			&& (
+				raw.propertyOperator?.valid === true
+				|| (
+					raw.sep?.left?.valid === true
+					&& (
+						raw.sep.right === undefined
+						|| raw.sep?.right.valid
+					)
+				)
+			)
+		)
+	)
+	return {
+		property: undefined,
+		propertyOperator: undefined,
+		sep: undefined,
+		...raw,
+		isNode: true,
+		type: AST_TYPE.CONDITION,
+		valid
+	}
+}

package/src/ast/createExpressionNode.ts

@@ -0,0 +1,21 @@
+import { AST_TYPE, type ExpressionNode,type RawNode } from "../types/ast.js"
+import { isNode } from "../utils/isNode.js"
+
+
+export function createExpressionNode<TValid extends boolean = boolean>(
+	raw: RawNode< ExpressionNode<TValid>>
+): ExpressionNode<TValid> {
+	const valid = (
+		raw.operator.valid &&
+		isNode(raw.left) &&
+		raw.left.valid &&
+		isNode(raw.right) &&
+		raw.right.valid
+	)
+	return {
+		...raw,
+		isNode: true,
+		valid,
+		type: AST_TYPE.EXPRESSION,
+	}
+}

package/src/ast/createGroupNode.ts

@@ -0,0 +1,46 @@
+import { AST_TYPE, type ConditionNode, type GroupNode, type RawNode, type TOKEN_TYPE, type ValidToken } from "../types/ast.js"
+import { isNode } from "../utils/isNode.js"
+import { isToken } from "../utils/isToken.js"
+
+
+export function createGroupNode<
+	TValid extends boolean = boolean,
+	TPrefixable extends boolean = true,
+	TPrefix extends
+		TPrefixable extends true
+			? ConditionNode<TValid> |
+			ValidToken<TOKEN_TYPE.NOT> |
+			undefined
+			: ValidToken<TOKEN_TYPE.NOT> |
+			undefined =
+		TPrefixable extends true
+			? ConditionNode<TValid> |
+			ValidToken<TOKEN_TYPE.NOT> |
+			undefined
+			: ValidToken<TOKEN_TYPE.NOT>,
+>(raw: {
+	prefix: TPrefix
+} & RawNode<GroupNode<TValid>>): GroupNode<TValid, TPrefixable, TPrefix> {
+	return {
+		...raw,
+		isNode: true,
+		valid: (
+			(
+				raw.prefix === undefined
+				|| (isToken(raw.prefix) && raw.prefix.valid)
+				|| (isNode(raw.prefix) && raw.prefix.valid)
+			)
+			&& isNode(raw.expression)
+			&& raw.expression.valid
+			&& (
+				raw.paren === undefined
+				|| (
+					raw.paren.left.valid
+					&& raw.paren.right.valid
+				)
+			)
+		),
+		type: AST_TYPE.GROUP,
+	}
+}
+		

package/src/ast/createNormalizedCondition.ts

@@ -0,0 +1,12 @@
+import { AST_TYPE, type NormalizedCondition } from "../types/ast.js"
+
+
+export function createCondition<
+	TOp extends string = string,
+	TValue = any,
+>(raw: Omit<NormalizedCondition<TOp, TValue>, "type">): NormalizedCondition<TOp, TValue> {
+	return {
+		...raw,
+		type: AST_TYPE.NORMALIZED_CONDITION,
+	}
+}

package/src/ast/createNormalizedExpression.ts

@@ -0,0 +1,9 @@
+import { AST_TYPE, type NormalizedExpression } from "../types/ast.js"
+
+
+export function createExpression<TType extends string = string, TValue = any>(raw: Omit<NormalizedExpression<TType, TValue>, "type">): NormalizedExpression<TType, TValue> {
+	return {
+		...raw,
+		type: AST_TYPE.NORMALIZED_EXPRESSION
+	}
+}

package/src/ast/createToken.ts

@@ -0,0 +1,26 @@
+import { ExpressitError } from "../internal/ExpressitError.js"
+import type { ErrorToken, RawToken, TOKEN_TYPE, ValidToken } from "../types/ast.js"
+import { ERROR_CODES } from "../types/errors.js"
+
+export function createToken<
+	TType extends TOKEN_TYPE,
+>(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,
+>(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)
+	}
+	return {
+		...raw,
+		valid: typeof (raw as any).expected === "undefined",
+		isToken: true,
+	} as any
+}
+

package/src/ast/createVariableNode.ts

@@ -0,0 +1,18 @@
+import { AST_TYPE, type RawNode, type VariableNode } from "../types/ast.js"
+
+export function createVariableNode<
+TValid extends boolean = boolean,
+>(raw: RawNode<VariableNode<TValid>>): VariableNode<TValid> {
+	return {
+		...raw,
+		isNode: true,
+		valid: (raw.value.valid && (
+			raw.quote === undefined ||
+			(
+				raw.quote.left.valid &&
+				raw.quote.right.valid
+			)
+		)) as TValid,
+		type: AST_TYPE.VARIABLE,
+	}
+}

package/src/ast/error.ts

@@ -0,0 +1,9 @@
+import { createToken } from "./createToken.js"
+
+import { type ErrorToken,type TOKEN_TYPE } from "../types/ast.js"
+
+export function error<T extends TOKEN_TYPE>(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 })
+}
+