@playcanvas/attribute-parser 1.10.2 → 1.11.0

package/types/utils/attribute-utils.d.ts

@@ -1,4 +1,30 @@
-export function getTag(tag: string, node: import("typescript").Node): import("typescript").JSDocTag | null;
-export function hasTag(tag: string, node: import("typescript").Node): boolean;
-export function isInterface(node: import("typescript").Node): boolean;
-export function isStaticMember(member: import("typescript").Node): boolean;
+import type { Declaration, Node } from 'typescript';
+/**
+ * @file Utility functions for parsing Script attributes.
+ */
+/**
+ * Returns a JSDoc tag from a node if it exists
+ * @param tag - The tag to search for
+ * @param node - The node to analyze
+ * @returns The tag node or null if not found
+ */
+export declare const getTag: (tag: string, node: Node) => import("typescript").JSDocTag;
+/**
+ * Checks if a node has a specific JSDoc tag.
+ * @param tag - The tag to search for
+ * @param node - The node to analyze
+ * @returns True if the tag is found
+ */
+export declare const hasTag: (tag: string, node: Node) => boolean;
+/**
+ * Checks if the JSDoc node node has an '@interface' tag
+ * @param node - The node to analyze
+ * @returns True if the node is an interface
+ */
+export declare const isInterface: (node: Node) => boolean;
+/**
+ * Checks if a node is a scriptName property
+ * @param member - The node to analyze
+ * @returns True if the node is a scriptName property
+ */
+export declare const isStaticMember: (member: Declaration) => boolean;

package/types/utils/generic-utils.d.ts

@@ -2,8 +2,8 @@
  * This merges two arrays together, filling in the missing values
  * in the first array with values from the second array.
  *
- * @param {array} a - The first array
- * @param {array} b - The second array
- * @returns {array} - The merged array
+ * @param a - The first array
+ * @param b - The second array
+ * @returns The merged array
  */
-export function zipArrays(a: any[], b: any[]): any[];
+export declare function zipArrays<T>(a: T[], b: T[]): T[];

package/types/utils/tag-utils.d.ts

@@ -1,16 +1,17 @@
+import type { VirtualTypeScriptEnvironment } from '@typescript/vfs';
 /**
  * Parses a tag value into a boolean, number, array or string
- * @param {string} input - The tag value to parse
- * @returns {boolean|number|string|Array<any>} - The parsed value
+ * @param input - The tag value to parse
+ * @returns The parsed value
  */
-export function parseTag(input?: string): boolean | number | string | Array<any>;
+export declare function parseTag(input?: string): string | number | boolean | any[];
 /**
  * Validates that a tag value matches the expected type
  *
- * @param {String} value - The value to be validated.
- * @param {String} typeAnnotation - The TypeScript type annotation as a string.
- * @param {import('@typescript/vfs').VirtualTypeScriptEnvironment} env - The environment containing the language service and file creation utilities.
+ * @param value - The value to be validated.
+ * @param typeAnnotation - The TypeScript type annotation as a string.
+ * @param env - The environment containing the language service and file creation utilities.
  * @throws Will throw an error if the value does not conform to the typeAnnotation.
- * @returns {true} if validation passes without type errors.
+ * @returns true if validation passes without type errors.
  */
-export function validateTag(value: string, typeAnnotation: string, env: import("@typescript/vfs").VirtualTypeScriptEnvironment): true;
+export declare function validateTag(value: string, typeAnnotation: string, env: VirtualTypeScriptEnvironment): boolean;

package/types/utils/ts-utils.d.ts

@@ -1,103 +1,147 @@
-export function createDefaultMapFromCDN(options: any, prefix: any, ts: any): Promise<Map<any, any>>;
+import * as ts from 'typescript';
+/**
+ * A TS AST node with internal properties that are absent from the public type definitions.
+ */
+export type InternalNode = ts.Node & {
+    jsDoc?: ts.JSDoc[];
+    initializer?: ts.Expression;
+    name?: ts.DeclarationName;
+    type?: ts.TypeNode;
+    members?: ts.NodeArray<ts.Node>;
+    properties?: ts.NodeArray<ts.Node>;
+    symbol?: ts.Symbol;
+};
+/**
+ * A literal value extracted from an AST node.
+ */
+export type LiteralValue = string | number | boolean | null | undefined | ts.PseudoBigInt | LiteralValue[] | {
+    [key: string]: LiteralValue;
+};
+export declare function createDefaultMapFromCDN(options: ts.CompilerOptions, prefix: string, tsLib: typeof ts): Promise<Map<string, string>>;
 /**
- * Returns an array of exported nodes from a TypeScript source file.
- * @param {import('typescript').Program} program - The TypeScript program
- * @param {import('typescript').SourceFile} sourceFile - The TypeScript source file
- * @returns {let map: Map<string, Set<import('typescript').Node>>} - A Map of exported nodes
+ * Returns a map of exported nodes from a TypeScript source file.
+ * @param program - The TypeScript program
+ * @param sourceFile - The TypeScript source file
+ * @returns A Map of exported nodes
  */
-export function getExportedNodes(program: import("typescript").Program, sourceFile: import("typescript").SourceFile): let;
+export declare function getExportedNodes(program: ts.Program, sourceFile: ts.SourceFile): Map<string, ts.Node>;
 /**
  * Checks if the node or its aliased symbol is a class declaration.
  *
- * @param {import('typescript').Node} node - The TypeScript node
- * @param {import('typescript').TypeChecker} typeChecker - The TypeScript type checker
- * @returns {boolean} - True if the node or its original declaration is a class declaration, false otherwise
+ * @param node - The TypeScript node
+ * @param typeChecker - The TypeScript type checker
+ * @returns True if the node or its original declaration is a class declaration, false otherwise
  */
-export function isAliasedClassDeclaration(node: import("typescript").Node, typeChecker: import("typescript").TypeChecker): boolean;
+export declare function isAliasedClassDeclaration(node: ts.Node, typeChecker: ts.TypeChecker): boolean;
 /**
  * Determines if a TypeScript node inherits from a specific base class.
- * @param {ts.ClassDeclaration} node - The TypeScript node to analyze
- * @param {ts.TypeChecker} typeChecker - The TypeScript type checker
- * @param {ts.Symbol} baseClassSymbol - The base class symbol to check inheritance against
- * @returns {boolean} - True if the node inherits from the base class
+ * @param node - The TypeScript node to analyze
+ * @param typeChecker - The TypeScript type checker
+ * @param baseClassSymbol - The base class symbol to check inheritance against
+ * @returns True if the node inherits from the base class
  */
-export function inheritsFrom(node: ts.ClassDeclaration, typeChecker: ts.TypeChecker, baseClassSymbol: ts.Symbol): boolean;
+export declare function inheritsFrom(node: ts.ClassDeclaration, typeChecker: ts.TypeChecker, baseClassSymbol: ts.Symbol): boolean;
 /**
  * Recursively gathers and flat maps and nodes that meet a specific filter.
- * @param {import('typescript').Node} node - The TypeScript node to analyze
- * @param {function} filter - A function to filter the nodes
- * @returns {import('typescript').Node[]} - An array of exported class declarations
+ * @param node - The TypeScript node to analyze
+ * @param filter - A function to filter the nodes
+ * @returns An array of exported class declarations
  */
-export function flatMapAnyNodes(node: import("typescript").Node, filter?: Function): import("typescript").Node[];
+export declare function flatMapAnyNodes(node: ts.Node, filter?: (node: ts.Node) => boolean): ts.Node[];
 /**
  * Retrieves the JSDoc-style comments associated with a specific AST node.
  *
- * @param {import('typescript').Node} node - The TypeScript node to analyze
- * @param {string} text - The full text content of the source file
- * @param {import('typescript').TypeChecker} typeChecker - The TypeScript type checker
- * @returns {{ memberName: string, member: Node, range: import('typescript').CommentRange}[]} - An array of comment ranges
+ * @param node - The TypeScript node to analyze
+ * @param typeChecker - The TypeScript type checker
+ * @returns An array of members with JSDoc comments
  */
-export function getJSDocTags(node: import("typescript").Node, typeChecker: import("typescript").TypeChecker): {
+export declare function getJSDocTags(node: ts.Node, typeChecker: ts.TypeChecker): {
     memberName: string;
-    member: Node;
-    range: import("typescript").CommentRange;
+    member: ts.Node;
 }[];
 /**
  * Determines if a TypeScript node is an enum.
- * @param {import('typescript').Node} node - The TypeScript node to analyze
- * @returns {boolean} - True if the node is an enum
+ * @param node - The TypeScript node to analyze
+ * @returns True if the node is an enum
  */
-export function isEnum(node: import("typescript").Node): boolean;
+export declare function isEnum(node: ts.Node): boolean;
 /**
  * Determines the primitive type for enums, or falls back to the actual type name.
  *
- * @param {ts.Type} type - The type to inspect.
- * @param {ts.TypeChecker} typeChecker - The TypeScript type checker.
- * @returns {'string' | 'boolean' | 'number' | null} - The primitive type of the enum or the type's name.
+ * @param type - The type to inspect.
+ * @param typeChecker - The TypeScript type checker.
+ * @returns The primitive type of the enum or null.
  */
-export function getPrimitiveEnumType(type: ts.Type, typeChecker: ts.TypeChecker): "string" | "boolean" | "number" | null;
+export declare function getPrimitiveEnumType(type: ts.Type, typeChecker: ts.TypeChecker): "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
 /**
  * Gets the inferred type of a TypeScript node.
  *
- * @param {ts.Node} node - The TypeScript node to analyze
- * @param {ts.TypeChecker} typeChecker - The TypeScript type checker
- * @returns {{ array: boolean, name: string | undefined, type: Type | null }} - The inferred type of the node
+ * @param node - The TypeScript node to analyze
+ * @param typeChecker - The TypeScript type checker
+ * @returns The inferred type of the node
  */
-export function getType(node: ts.Node, typeChecker: ts.TypeChecker): {
+export declare function getType(node: ts.Node, typeChecker: ts.TypeChecker): {
+    type: ts.Type;
+    name: string;
     array: boolean;
-    name: string | undefined;
-    type: Type | null;
+    isMixedUnion: boolean;
 };
 /**
  * Parses a numerical string into a number. Handles hexadecimal, binary,
  * octal, exponential notation and underscore notation
  *
- * @param {string} input - The string to parse
- * @returns {number} The parsed number, or NaN if the input is not a number
+ * @param input - The string to parse
+ * @returns The parsed number, or NaN if the input is not a number
  */
-export function parseNumber(input: string): number;
+export declare function parseNumber(input: string): number;
 /**
  * Parses a string representation of a numerical array into an array of numbers.
  *
- * @param {string} input - The string to parse
- * @returns {number[]} - The parsed array of numbers
- * @throws {Error} - If the input contains invalid characters or is not a valid array
+ * @param input - The string to parse
+ * @returns The parsed array of numbers
+ * @throws If the input contains invalid characters or is not a valid array
  */
-export function parseStringToNumericalArray(input: string): number[];
+export declare function parseStringToNumericalArray(input: string): number[];
+/**
+ * Checks if the given node is a numerical literal or a unary expression.
+ * @param node - The node to check
+ * @returns True if the node is a numeric literal
+ */
+export declare const isNumericLiteral: (node: ts.Node) => boolean;
+/**
+ * If the given node is a numeric literal, returns the parsed number.
+ * @param node - The node to check
+ * @param isArgument - True if the node is an argument in a parameter list
+ * @returns The parsed number
+ * @throws {ParsingError} If the node is not a numeric literal
+ */
+export declare const parseFloatNode: (node: ts.Node, isArgument?: boolean) => number;
+/**
+ * If the given node is a boolean literal, returns the parsed boolean.
+ * @param node - The node to check
+ * @returns The parsed boolean
+ */
+export declare const parseBooleanNode: (node: ts.Node) => boolean;
 /**
  * Attempts to extract a literal value from a TypeScript node. This function
  * supports various types of literals and expressions, including object literals,
  * array literals, identifiers, and unary expressions.
  *
- * @param {import('typescript').Node} node - The AST node to evaluate
- * @param {import('typescript').TypeChecker} typeChecker - The TypeScript type checker
- * @returns {any} - The extracted literal value
- */
-export function getLiteralValue(node: import("typescript").Node, typeChecker: import("typescript").TypeChecker): any;
-export function isNumericLiteral(node: import("typescript").Node): boolean;
-export function parseFloatNode(node: import("typescript").Node, isArgument?: boolean): number;
-export function parseBooleanNode(node: import("typescript").Node): boolean;
-export function parseStringNode(node: import("typescript").Node): string;
-export function parseArrayLiteralNode(node: any, isArgument?: boolean): any;
-export function parseArrayLiteral(args: ts.Node[]): number[];
-import * as ts from 'typescript';
+ * @param node - The AST node to evaluate
+ * @param typeChecker - The TypeScript type checker
+ * @returns The extracted literal value
+ */
+export declare function getLiteralValue(node: ts.Node, typeChecker?: ts.TypeChecker): LiteralValue;
+/**
+ * If the given node is a string literal, returns the parsed string.
+ * @param node - The node to check
+ * @returns The parsed string
+ */
+export declare const parseStringNode: (node: ts.Node) => string;
+export declare const parseArrayLiteralNode: (node: ts.Node, isArgument?: boolean) => any;
+/**
+ * Parses the first argument as an array literal.
+ * @param args - The arguments to parse
+ * @returns The parsed array
+ */
+export declare const parseArrayLiteral: (args: readonly ts.Node[]) => any;