@tsrx/core 0.1.47 → 0.1.49

package/types/parse.d.ts

@@ -420,6 +420,8 @@ export namespace Parse {
 	export interface AcornTypeScriptExtensions {
 		tokTypes: AcornTypeScriptTokTypes;
 		tokContexts: AcornTypeScriptTokContexts;
+		/** Whether a token type can start/continue an identifier (incl. TS soft keywords) */
+		tokenIsIdentifier(token: TokenType): boolean;
 	}
 
 	export interface AcornTypeScriptFunctionBodyConfig {
@@ -427,6 +429,31 @@ export namespace Parse {
 		isClassMethod?: boolean;
 	}
 
+	/**
+	 * Snapshot of tokenizer state returned by `lookahead()`, mirroring
+	 * @sveltejs/acorn-typescript's saved lookahead state. Callers inspect the
+	 * upcoming token (`type`/`value`/`start`/`containsEsc`) without consuming it,
+	 * and pass the snapshot to the `*WithState` contextual helpers.
+	 */
+	export interface LookaheadState {
+		pos: number;
+		type: TokenType;
+		value: string | number | RegExp | bigint | null;
+		start: number;
+		end: number;
+		startLoc: AST.Position;
+		endLoc: AST.Position;
+		lastTokEnd: number;
+		lastTokStart: number;
+		lastTokStartLoc: AST.Position;
+		lastTokEndLoc: AST.Position;
+		context: TokContext[];
+		curLine: number;
+		lineStart: number;
+		curPosition: () => AST.Position;
+		containsEsc: boolean;
+	}
+
 	interface Scope {
 		flags: number;
 		var: string[];
@@ -496,6 +523,11 @@ export namespace Parse {
 		inFunction: boolean;
 		/** Whether @sveltejs/acorn-typescript is currently parsing a TypeScript type */
 		inType: boolean;
+		/**
+		 * `value`/`type` kind of the import or export declaration currently being
+		 * parsed (@sveltejs/acorn-typescript). `undefined` when not inside one.
+		 */
+		importOrExportOuterKind?: 'value' | 'type';
 		/** Stack of label names for break/continue statements */
 		labels: Array<{ kind: string | null; name?: string; statementStart?: number }>;
 		/** Current scope flags stack */
@@ -756,6 +788,23 @@ export namespace Parse {
 		 */
 		expectContextual(name: string): void;
 
+		/**
+		 * Like `isContextual`, but tests a `lookahead()` snapshot instead of the
+		 * current token (@sveltejs/acorn-typescript).
+		 * @param keyword Keyword to check (e.g. "from", "defer")
+		 * @param state Lookahead snapshot to test
+		 */
+		isContextualWithState(keyword: string, state: LookaheadState): boolean;
+
+		/**
+		 * If `state` is the contextual keyword `name`, consume `nextCount` tokens
+		 * and return true (@sveltejs/acorn-typescript).
+		 * @param name Contextual keyword to eat (e.g. "type", "defer")
+		 * @param nextCount Number of tokens to advance when it matches
+		 * @param state Lookahead snapshot to test
+		 */
+		ts_eatContextualWithState(name: string, nextCount: number, state: LookaheadState): boolean;
+
 		/**
 		 * Check if semicolon can be inserted at current position (ASI)
 		 */
@@ -831,10 +880,11 @@ export namespace Parse {
 		// Lookahead
 		// ============================================================
 		/**
-		 * Look ahead one token without consuming
-		 * @returns Object with type and value of next token
+		 * Look ahead `number` tokens (default 1) without consuming, returning a
+		 * snapshot of the tokenizer state at that position.
+		 * @param number How many tokens to look ahead (default 1)
 		 */
-		lookahead(): { type: TokenType; value: any };
+		lookahead(number?: number): LookaheadState;
 
 		/**
 		 * Get next token start position
@@ -1461,7 +1511,17 @@ export namespace Parse {
 		// Module Parsing (Import/Export)
 		// ============================================================
 		/** Parse import declaration */
-		parseImport(node: AST.Node): AST.ImportDeclaration;
+		parseImport(node: AST.TSRXImportDeclaration): AST.TSRXImportDeclaration;
+
+		/**
+		 * Parse a TypeScript import-equals declaration, `import x = require('y')`
+		 * or `import x = A.B` (@sveltejs/acorn-typescript). Typed as
+		 * `ImportDeclaration` because estree has no `TSImportEqualsDeclaration`.
+		 */
+		tsParseImportEqualsDeclaration(node: AST.Node, isExport?: boolean): AST.ImportDeclaration;
+
+		/** Parse an optional import-attributes clause (`with { … }` / `assert { … }`) */
+		parseMaybeImportAttributes(node: AST.Node): void;
 
 		/** Parse import specifiers */
 		parseImportSpecifiers(): AST.ImportSpecifier[];
@@ -1617,8 +1677,7 @@ export namespace Parse {
 		 * Parse JSX namespaced name (ns:name)
 		 */
 		jsx_parseNamespacedName():
-			| ESTreeJSX.JSXNamespacedName
-			| ReturnType<Parser['jsx_parseIdentifier']>;
+			ESTreeJSX.JSXNamespacedName | ReturnType<Parser['jsx_parseIdentifier']>;
 
 		/**
 		 * Parse JSX element name (identifier, member, namespaced, or a dynamic
@@ -1635,8 +1694,7 @@ export namespace Parse {
 		 * @returns Attribute value (expression, string, or element)
 		 */
 		jsx_parseAttributeValue():
-			| ESTreeJSX.JSXExpressionContainer
-			| ReturnType<Parser['parseExprAtom']>;
+			ESTreeJSX.JSXExpressionContainer | ReturnType<Parser['parseExprAtom']>;
 
 		/**
 		 * Parse JSX empty expression (for {})

package/types/runtime/ref.d.ts

@@ -14,11 +14,7 @@ export type RefValue<T = Element> =
 	| undefined;
 
 export type MergeableRef<T> =
-	| MergeableRefCallback<T>
-	| MergeableRefObject<T>
-	| MergeableVueRef<T>
-	| null
-	| undefined;
+	MergeableRefCallback<T> | MergeableRefObject<T> | MergeableVueRef<T> | null | undefined;
 
 export function mergeRefs<T = any>(...refs: Array<MergeableRef<T>>): (node: T | null) => () => void;
 export function isRefProp(value: unknown): boolean;