ztimson/utils
1
0
Fork 0
Code Issues Pull Requests Actions Packages Releases Wiki Activity

init

Browse Source
This commit is contained in:
Zakary Timson
2024-02-07 01:33:07 -05:00
commit c1af19d441
4088 changed files with 1260170 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
node_modules/@vue/language-core/out/parsers/scriptRanges.d.ts generated vendored Normal file
View File

@ -0,0 +1,16 @@
import type { TextRange } from '../types';
import type * as ts from 'typescript/lib/tsserverlibrary';
export interface ScriptRanges extends ReturnType<typeof parseScriptRanges> {
}
export declare function parseScriptRanges(ts: typeof import('typescript/lib/tsserverlibrary'), ast: ts.SourceFile, hasScriptSetup: boolean, withNode: boolean): {
exportDefault: (TextRange & {
expression: TextRange;
args: TextRange;
argsNode: ts.ObjectLiteralExpression | undefined;
componentsOption: TextRange | undefined;
componentsOptionNode: ts.ObjectLiteralExpression | undefined;
nameOption: TextRange | undefined;
}) | undefined;
bindings: TextRange[];
};
//# sourceMappingURL=scriptRanges.d.ts.map

58
node_modules/@vue/language-core/out/parsers/scriptRanges.js generated vendored Normal file
View File

@ -0,0 +1,58 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.parseScriptRanges = void 0;
const scriptSetupRanges_1 = require("./scriptSetupRanges");
function parseScriptRanges(ts, ast, hasScriptSetup, withNode) {
let exportDefault;
const bindings = hasScriptSetup ? (0, scriptSetupRanges_1.parseBindingRanges)(ts, ast) : [];
ast.forEachChild(raw => {
if (ts.isExportAssignment(raw)) {
let node = raw;
while (ts.isAsExpression(node.expression) || ts.isParenthesizedExpression(node.expression)) { // fix https://github.com/vuejs/language-tools/issues/1882
node = node.expression;
}
let obj;
if (ts.isObjectLiteralExpression(node.expression)) {
obj = node.expression;
}
else if (ts.isCallExpression(node.expression) && node.expression.arguments.length) {
const arg0 = node.expression.arguments[0];
if (ts.isObjectLiteralExpression(arg0)) {
obj = arg0;
}
}
if (obj) {
let componentsOptionNode;
let nameOptionNode;
obj.forEachChild(node => {
if (ts.isPropertyAssignment(node) && ts.isIdentifier(node.name)) {
if (node.name.escapedText === 'components' && ts.isObjectLiteralExpression(node.initializer)) {
componentsOptionNode = node.initializer;
}
if (node.name.escapedText === 'name') {
nameOptionNode = node.initializer;
}
}
});
exportDefault = {
..._getStartEnd(raw),
expression: _getStartEnd(node.expression),
args: _getStartEnd(obj),
argsNode: withNode ? obj : undefined,
componentsOption: componentsOptionNode ? _getStartEnd(componentsOptionNode) : undefined,
componentsOptionNode: withNode ? componentsOptionNode : undefined,
nameOption: nameOptionNode ? _getStartEnd(nameOptionNode) : undefined,
};
}
}
});
return {
exportDefault,
bindings,
};
function _getStartEnd(node) {
return (0, scriptSetupRanges_1.getStartEnd)(node, ast);
}
}
exports.parseScriptRanges = parseScriptRanges;
//# sourceMappingURL=scriptRanges.js.map

56
node_modules/@vue/language-core/out/parsers/scriptSetupRanges.d.ts generated vendored Normal file
View File

@ -0,0 +1,56 @@
import type * as ts from 'typescript/lib/tsserverlibrary';
import type { VueCompilerOptions, TextRange } from '../types';
export interface ScriptSetupRanges extends ReturnType<typeof parseScriptSetupRanges> {
}
export declare function parseScriptSetupRanges(ts: typeof import('typescript/lib/tsserverlibrary'), ast: ts.SourceFile, vueCompilerOptions: VueCompilerOptions): {
leadingCommentEndOffset: number;
importSectionEndOffset: number;
bindings: TextRange[];
props: {
name?: string | undefined;
define?: (TextRange & {
arg?: TextRange | undefined;
typeArg?: TextRange | undefined;
} & {
statement: TextRange;
}) | undefined;
withDefaults?: (TextRange & {
arg?: TextRange | undefined;
}) | undefined;
};
slots: {
name?: string | undefined;
define?: (TextRange & {
arg?: TextRange | undefined;
typeArg?: TextRange | undefined;
}) | undefined;
};
emits: {
name?: string | undefined;
define?: (TextRange & {
arg?: TextRange | undefined;
typeArg?: TextRange | undefined;
}) | undefined;
};
expose: {
name?: string | undefined;
define?: (TextRange & {
arg?: TextRange | undefined;
typeArg?: TextRange | undefined;
}) | undefined;
};
defineProp: {
name: TextRange | undefined;
nameIsString: boolean;
type: TextRange | undefined;
defaultValue: TextRange | undefined;
required: boolean;
}[];
};
export declare function parseBindingRanges(ts: typeof import('typescript/lib/tsserverlibrary'), sourceFile: ts.SourceFile): TextRange[];
export declare function findBindingVars(ts: typeof import('typescript/lib/tsserverlibrary'), left: ts.BindingName, sourceFile: ts.SourceFile): TextRange[];
export declare function getStartEnd(node: ts.Node, sourceFile: ts.SourceFile): {
start: number;
end: number;
};
//# sourceMappingURL=scriptSetupRanges.d.ts.map

292
node_modules/@vue/language-core/out/parsers/scriptSetupRanges.js generated vendored Normal file
View File

@ -0,0 +1,292 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.getStartEnd = exports.findBindingVars = exports.parseBindingRanges = exports.parseScriptSetupRanges = void 0;
function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
let foundNonImportExportNode = false;
let importSectionEndOffset = 0;
const props = {};
const slots = {};
const emits = {};
const expose = {};
const definePropProposalA = vueCompilerOptions.experimentalDefinePropProposal === 'kevinEdition' || ast.getFullText().trimStart().startsWith('// @experimentalDefinePropProposal=kevinEdition');
const definePropProposalB = vueCompilerOptions.experimentalDefinePropProposal === 'johnsonEdition' || ast.getFullText().trimStart().startsWith('// @experimentalDefinePropProposal=johnsonEdition');
const defineProp = [];
const bindings = parseBindingRanges(ts, ast);
const text = ast.getFullText();
const leadingCommentEndOffset = ts.getLeadingCommentRanges(text, 0)?.reverse()[0].end ?? 0;
ast.forEachChild(node => {
const isTypeExport = (ts.isTypeAliasDeclaration(node) || ts.isInterfaceDeclaration(node)) && node.modifiers?.some(mod => mod.kind === ts.SyntaxKind.ExportKeyword);
if (!foundNonImportExportNode
&& !ts.isImportDeclaration(node)
&& !isTypeExport
&& !ts.isEmptyStatement(node)
// fix https://github.com/vuejs/language-tools/issues/1223
&& !ts.isImportEqualsDeclaration(node)) {
const commentRanges = ts.getLeadingCommentRanges(text, node.getFullStart());
if (commentRanges?.length) {
const commentRange = commentRanges.sort((a, b) => a.pos - b.pos)[0];
importSectionEndOffset = commentRange.pos;
}
else {
importSectionEndOffset = node.getStart(ast);
}
foundNonImportExportNode = true;
}
});
ast.forEachChild(child => visitNode(child, [ast]));
return {
leadingCommentEndOffset,
importSectionEndOffset,
bindings,
props,
slots,
emits,
expose,
defineProp,
};
function _getStartEnd(node) {
return getStartEnd(node, ast);
}
function parseDefineFunction(node) {
return {
..._getStartEnd(node),
arg: node.arguments.length ? _getStartEnd(node.arguments[0]) : undefined,
typeArg: node.typeArguments?.length ? _getStartEnd(node.typeArguments[0]) : undefined,
};
}
function visitNode(node, parents) {
const parent = parents[parents.length - 1];
if (ts.isCallExpression(node)
&& ts.isIdentifier(node.expression)) {
const callText = node.expression.getText(ast);
if (vueCompilerOptions.macros.defineModel.includes(callText)) {
let name;
let options;
if (node.arguments.length >= 2) {
name = _getStartEnd(node.arguments[0]);
options = node.arguments[1];
}
else if (node.arguments.length >= 1) {
if (ts.isStringLiteral(node.arguments[0])) {
name = _getStartEnd(node.arguments[0]);
}
else {
options = node.arguments[0];
}
}
let required = false;
if (options && ts.isObjectLiteralExpression(options)) {
for (const property of options.properties) {
if (ts.isPropertyAssignment(property) && ts.isIdentifier(property.name) && property.name.getText(ast) === 'required' && property.initializer.kind === ts.SyntaxKind.TrueKeyword) {
required = true;
break;
}
}
}
defineProp.push({
name,
nameIsString: true,
type: node.typeArguments?.length ? _getStartEnd(node.typeArguments[0]) : undefined,
defaultValue: undefined,
required,
});
}
else if (callText === 'defineProp') {
if (definePropProposalA) {
let required = false;
if (node.arguments.length >= 2) {
const secondArg = node.arguments[1];
if (ts.isObjectLiteralExpression(secondArg)) {
for (const property of secondArg.properties) {
if (ts.isPropertyAssignment(property) && ts.isIdentifier(property.name) && property.name.getText(ast) === 'required' && property.initializer.kind === ts.SyntaxKind.TrueKeyword) {
required = true;
break;
}
}
}
}
if (node.arguments.length >= 1) {
defineProp.push({
name: _getStartEnd(node.arguments[0]),
nameIsString: true,
type: node.typeArguments?.length ? _getStartEnd(node.typeArguments[0]) : undefined,
defaultValue: undefined,
required,
});
}
else if (ts.isVariableDeclaration(parent)) {
defineProp.push({
name: _getStartEnd(parent.name),
nameIsString: false,
type: node.typeArguments?.length ? _getStartEnd(node.typeArguments[0]) : undefined,
defaultValue: undefined,
required,
});
}
}
else if (definePropProposalB && ts.isVariableDeclaration(parent)) {
defineProp.push({
name: _getStartEnd(parent.name),
nameIsString: false,
defaultValue: node.arguments.length >= 1 ? _getStartEnd(node.arguments[0]) : undefined,
type: node.typeArguments?.length ? _getStartEnd(node.typeArguments[0]) : undefined,
required: node.arguments.length >= 2 && node.arguments[1].kind === ts.SyntaxKind.TrueKeyword,
});
}
}
else if (vueCompilerOptions.macros.defineSlots.includes(callText)) {
slots.define = parseDefineFunction(node);
if (ts.isVariableDeclaration(parent)) {
slots.name = parent.name.getText(ast);
}
}
else if (vueCompilerOptions.macros.defineEmits.includes(callText)) {
emits.define = parseDefineFunction(node);
if (ts.isVariableDeclaration(parent)) {
emits.name = parent.name.getText(ast);
}
}
else if (vueCompilerOptions.macros.defineExpose.includes(callText)) {
expose.define = parseDefineFunction(node);
}
else if (vueCompilerOptions.macros.defineProps.includes(callText)) {
let statementRange;
for (let i = parents.length - 1; i >= 0; i--) {
if (ts.isStatement(parents[i])) {
const statement = parents[i];
statement.forEachChild(child => {
const range = _getStartEnd(child);
statementRange ??= range;
statementRange.end = range.end;
});
break;
}
}
if (!statementRange) {
statementRange = _getStartEnd(node);
}
props.define = {
...parseDefineFunction(node),
statement: statementRange,
};
if (ts.isVariableDeclaration(parent)) {
props.name = parent.name.getText(ast);
}
if (node.arguments.length) {
props.define.arg = _getStartEnd(node.arguments[0]);
}
if (node.typeArguments?.length) {
props.define.typeArg = _getStartEnd(node.typeArguments[0]);
}
}
else if (vueCompilerOptions.macros.withDefaults.includes(callText)) {
props.withDefaults = _getStartEnd(node);
if (node.arguments.length >= 2) {
const arg = node.arguments[1];
props.withDefaults.arg = _getStartEnd(arg);
}
if (ts.isVariableDeclaration(parent)) {
props.name = parent.name.getText(ast);
}
}
}
node.forEachChild(child => {
parents.push(node);
visitNode(child, parents);
parents.pop();
});
}
}
exports.parseScriptSetupRanges = parseScriptSetupRanges;
function parseBindingRanges(ts, sourceFile) {
const bindings = [];
sourceFile.forEachChild(node => {
if (ts.isVariableStatement(node)) {
for (const node_2 of node.declarationList.declarations) {
const vars = _findBindingVars(node_2.name);
for (const _var of vars) {
bindings.push(_var);
}
}
}
else if (ts.isFunctionDeclaration(node)) {
if (node.name && ts.isIdentifier(node.name)) {
bindings.push(_getStartEnd(node.name));
}
}
else if (ts.isClassDeclaration(node)) {
if (node.name) {
bindings.push(_getStartEnd(node.name));
}
}
else if (ts.isEnumDeclaration(node)) {
bindings.push(_getStartEnd(node.name));
}
if (ts.isImportDeclaration(node)) {
if (node.importClause && !node.importClause.isTypeOnly) {
if (node.importClause.name) {
bindings.push(_getStartEnd(node.importClause.name));
}
if (node.importClause.namedBindings) {
if (ts.isNamedImports(node.importClause.namedBindings)) {
for (const element of node.importClause.namedBindings.elements) {
bindings.push(_getStartEnd(element.name));
}
}
else if (ts.isNamespaceImport(node.importClause.namedBindings)) {
bindings.push(_getStartEnd(node.importClause.namedBindings.name));
}
}
}
}
});
return bindings;
function _getStartEnd(node) {
return getStartEnd(node, sourceFile);
}
function _findBindingVars(left) {
return findBindingVars(ts, left, sourceFile);
}
}
exports.parseBindingRanges = parseBindingRanges;
function findBindingVars(ts, left, sourceFile) {
const vars = [];
worker(left);
return vars;
function worker(_node) {
if (ts.isIdentifier(_node)) {
vars.push(getStartEnd(_node, sourceFile));
}
// { ? } = ...
// [ ? ] = ...
else if (ts.isObjectBindingPattern(_node) || ts.isArrayBindingPattern(_node)) {
for (const property of _node.elements) {
if (ts.isBindingElement(property)) {
worker(property.name);
}
}
}
// { foo: ? } = ...
else if (ts.isPropertyAssignment(_node)) {
worker(_node.initializer);
}
// { foo } = ...
else if (ts.isShorthandPropertyAssignment(_node)) {
vars.push(getStartEnd(_node.name, sourceFile));
}
// { ...? } = ...
// [ ...? ] = ...
else if (ts.isSpreadAssignment(_node) || ts.isSpreadElement(_node)) {
worker(_node.expression);
}
}
}
exports.findBindingVars = findBindingVars;
function getStartEnd(node, sourceFile) {
return {
start: node.getStart(sourceFile),
end: node.getEnd(),
};
}
exports.getStartEnd = getStartEnd;
//# sourceMappingURL=scriptSetupRanges.js.map