forked from public/fvtt-cthulhu-eternal
151 lines
4.4 KiB
TypeScript
151 lines
4.4 KiB
TypeScript
/** Options for parsing imports. */
|
|
type Options = {
|
|
/**
|
|
* If set to a file path, then {@link Import.moduleSpecifier.resolved} of
|
|
* returned instances will be set to the result of calling
|
|
* `require.resolve(moduleSpecifier.value)` from the given file path.
|
|
* Otherwise, will be undefined.
|
|
*/
|
|
readonly resolveFrom?: string
|
|
}
|
|
|
|
/**
|
|
* A type representing what kind of module a specifier refers to.
|
|
*
|
|
* - 'unknown' if the module specifier is not a simple constant string literal
|
|
* - 'invalid' if the module specifier is the empty string
|
|
* - 'absolute' if the module specifier is an absolute file path
|
|
* - 'relative' if the module specifier is a relative file path
|
|
* - 'builtin' if the module specifier is the name of a builtin Node.js package
|
|
* - 'package' otherwise
|
|
*/
|
|
type ModuleSpecifierType =
|
|
| 'invalid'
|
|
| 'absolute'
|
|
| 'relative'
|
|
| 'builtin'
|
|
| 'package'
|
|
| 'unknown'
|
|
|
|
/**
|
|
* A type representing an import in JavaScript code.
|
|
*
|
|
* `code.substring(startIndex, endIndex)` returns the full import statement or
|
|
* expression.
|
|
*/
|
|
type Import = {
|
|
/** The start index of the import in the JavaScript (inclusive). */
|
|
startIndex: number
|
|
|
|
/** The end index of the import in the JavaScript (exclusive). */
|
|
endIndex: number
|
|
|
|
/** Whether the import is a dynamic import (e.g. `import('module')`). */
|
|
isDynamicImport: boolean
|
|
|
|
/**
|
|
* A type representing the code specifiying the module being imported.
|
|
*
|
|
* `code.substring(moduleSpecifier.startIndex, moduleSpecifier.endIndex)`
|
|
* returns the module specifier including quotes.
|
|
*/
|
|
moduleSpecifier: {
|
|
/**
|
|
* What kind of module the specifier refers to.
|
|
*
|
|
* 'unknown' when `moduleSpecifier.isConstant` is false.
|
|
*/
|
|
type: ModuleSpecifierType
|
|
|
|
/** The start index of the specifier in the JavaScript (inclusive). */
|
|
startIndex: number
|
|
|
|
/** The end index of the specifier in the JavaScript (exclusive). */
|
|
endIndex: number
|
|
|
|
/**
|
|
* True when the import is not a dynamic import (`isDynamicImport` is
|
|
* false), or when the import is a dynamic import where the specifier is a
|
|
* simple string literal (e.g. import('fs'), import("fs"), import(`fs`)).
|
|
*/
|
|
isConstant: boolean
|
|
|
|
/**
|
|
* The module specifier as it was written in the code. For non-constant
|
|
* dynamic imports it could be a complex expression.
|
|
*/
|
|
code: string
|
|
|
|
/**
|
|
* `code` without string literal quotes and unescaped if `isConstant` is
|
|
* true. Otherwise, it is undefined.
|
|
*/
|
|
value?: string
|
|
|
|
/** Set if the `resolveFrom` option is set and `value` is not undefined. */
|
|
resolved?: string
|
|
}
|
|
|
|
/**
|
|
* A type representing what is being imported from the module.
|
|
*
|
|
* Undefined if `isDynamicImport` is true.
|
|
*/
|
|
importClause?: {
|
|
/**
|
|
* The default import identifier or undefined if the import statement does
|
|
* not have a default import.
|
|
*/
|
|
default?: string
|
|
|
|
/**
|
|
* An array of objects representing the named imports of the import
|
|
* statement. It is empty if the import statement does not have any named
|
|
* imports. Each object in the array has a specifier field set to the
|
|
* imported identifier and a binding field set to the identifier for
|
|
* accessing the imported value.
|
|
* For example, `import { a, x as y } from 'something'` would have the
|
|
* following array:
|
|
* ```
|
|
* [{ specifier: 'a', binding: 'a' }, { specifier: 'x', binding: 'y' }]
|
|
* ```
|
|
*/
|
|
named: { specifier: string; binding: string }[]
|
|
|
|
/**
|
|
* The namespace import identifier or undefined if the import statement does
|
|
* not have a namespace import.
|
|
*/
|
|
namespace?: string
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A promise that resolves once WASM has finished loading.
|
|
*
|
|
* Await this promise to be certain calling `parseImportsSync` is safe.
|
|
*/
|
|
declare const wasmLoadPromise: Promise<void>
|
|
|
|
/**
|
|
* Returns a promise resolving to a lazy iterable/iterator that iterates over
|
|
* the imports in `code`.
|
|
*/
|
|
declare const parseImports: (
|
|
code: string,
|
|
options?: Options,
|
|
) => Promise<Iterable<Import>>
|
|
|
|
/**
|
|
* Returns a lazy iterable/iterator that iterates over the imports in `code`.
|
|
*
|
|
* @throws if called before WASM has finished loading. Await `wasmLoadPromise`
|
|
* to be sure it has finished.
|
|
*/
|
|
declare const parseImportsSync: (
|
|
code: string,
|
|
options?: Options,
|
|
) => Iterable<Import>
|
|
|
|
export { type Import, type ModuleSpecifierType, type Options, parseImports, parseImportsSync, wasmLoadPromise };
|