update
This commit is contained in:
@@ -0,0 +1,212 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.ClassAccessorProperty = ClassAccessorProperty;
|
||||
exports.ClassBody = ClassBody;
|
||||
exports.ClassExpression = exports.ClassDeclaration = ClassDeclaration;
|
||||
exports.ClassMethod = ClassMethod;
|
||||
exports.ClassPrivateMethod = ClassPrivateMethod;
|
||||
exports.ClassPrivateProperty = ClassPrivateProperty;
|
||||
exports.ClassProperty = ClassProperty;
|
||||
exports.StaticBlock = StaticBlock;
|
||||
exports._classMethodHead = _classMethodHead;
|
||||
var _t = require("@babel/types");
|
||||
const {
|
||||
isExportDefaultDeclaration,
|
||||
isExportNamedDeclaration
|
||||
} = _t;
|
||||
function ClassDeclaration(node, parent) {
|
||||
const inExport = isExportDefaultDeclaration(parent) || isExportNamedDeclaration(parent);
|
||||
if (!inExport || !this._shouldPrintDecoratorsBeforeExport(parent)) {
|
||||
this.printJoin(node.decorators);
|
||||
}
|
||||
if (node.declare) {
|
||||
this.word("declare");
|
||||
this.space();
|
||||
}
|
||||
if (node.abstract) {
|
||||
this.word("abstract");
|
||||
this.space();
|
||||
}
|
||||
this.word("class");
|
||||
if (node.id) {
|
||||
this.space();
|
||||
this.print(node.id);
|
||||
}
|
||||
this.print(node.typeParameters);
|
||||
if (node.superClass) {
|
||||
this.space();
|
||||
this.word("extends");
|
||||
this.space();
|
||||
this.print(node.superClass);
|
||||
this.print(node.superTypeParameters);
|
||||
}
|
||||
if (node.implements) {
|
||||
this.space();
|
||||
this.word("implements");
|
||||
this.space();
|
||||
this.printList(node.implements);
|
||||
}
|
||||
this.space();
|
||||
this.print(node.body);
|
||||
}
|
||||
function ClassBody(node) {
|
||||
this.tokenChar(123);
|
||||
if (node.body.length === 0) {
|
||||
this.tokenChar(125);
|
||||
} else {
|
||||
this.newline();
|
||||
const separator = classBodyEmptySemicolonsPrinter(this, node);
|
||||
separator == null || separator(-1);
|
||||
const exit = this.enterDelimited();
|
||||
this.printJoin(node.body, true, true, separator, true);
|
||||
exit();
|
||||
if (!this.endsWith(10)) this.newline();
|
||||
this.rightBrace(node);
|
||||
}
|
||||
}
|
||||
function classBodyEmptySemicolonsPrinter(printer, node) {
|
||||
if (!printer.tokenMap || node.start == null || node.end == null) {
|
||||
return null;
|
||||
}
|
||||
const indexes = printer.tokenMap.getIndexes(node);
|
||||
if (!indexes) return null;
|
||||
let k = 1;
|
||||
let occurrenceCount = 0;
|
||||
let nextLocIndex = 0;
|
||||
const advanceNextLocIndex = () => {
|
||||
while (nextLocIndex < node.body.length && node.body[nextLocIndex].start == null) {
|
||||
nextLocIndex++;
|
||||
}
|
||||
};
|
||||
advanceNextLocIndex();
|
||||
return i => {
|
||||
if (nextLocIndex <= i) {
|
||||
nextLocIndex = i + 1;
|
||||
advanceNextLocIndex();
|
||||
}
|
||||
const end = nextLocIndex === node.body.length ? node.end : node.body[nextLocIndex].start;
|
||||
let tok;
|
||||
while (k < indexes.length && printer.tokenMap.matchesOriginal(tok = printer._tokens[indexes[k]], ";") && tok.start < end) {
|
||||
printer.token(";", undefined, occurrenceCount++);
|
||||
k++;
|
||||
}
|
||||
};
|
||||
}
|
||||
function ClassProperty(node) {
|
||||
this.printJoin(node.decorators);
|
||||
if (!node.static && !this.format.preserveFormat) {
|
||||
var _node$key$loc;
|
||||
const endLine = (_node$key$loc = node.key.loc) == null || (_node$key$loc = _node$key$loc.end) == null ? void 0 : _node$key$loc.line;
|
||||
if (endLine) this.catchUp(endLine);
|
||||
}
|
||||
this.tsPrintClassMemberModifiers(node);
|
||||
if (node.computed) {
|
||||
this.tokenChar(91);
|
||||
this.print(node.key);
|
||||
this.tokenChar(93);
|
||||
} else {
|
||||
this._variance(node);
|
||||
this.print(node.key);
|
||||
}
|
||||
if (node.optional) {
|
||||
this.tokenChar(63);
|
||||
}
|
||||
if (node.definite) {
|
||||
this.tokenChar(33);
|
||||
}
|
||||
this.print(node.typeAnnotation);
|
||||
if (node.value) {
|
||||
this.space();
|
||||
this.tokenChar(61);
|
||||
this.space();
|
||||
this.print(node.value);
|
||||
}
|
||||
this.semicolon();
|
||||
}
|
||||
function ClassAccessorProperty(node) {
|
||||
var _node$key$loc2;
|
||||
this.printJoin(node.decorators);
|
||||
const endLine = (_node$key$loc2 = node.key.loc) == null || (_node$key$loc2 = _node$key$loc2.end) == null ? void 0 : _node$key$loc2.line;
|
||||
if (endLine) this.catchUp(endLine);
|
||||
this.tsPrintClassMemberModifiers(node);
|
||||
this.word("accessor", true);
|
||||
this.space();
|
||||
if (node.computed) {
|
||||
this.tokenChar(91);
|
||||
this.print(node.key);
|
||||
this.tokenChar(93);
|
||||
} else {
|
||||
this._variance(node);
|
||||
this.print(node.key);
|
||||
}
|
||||
if (node.optional) {
|
||||
this.tokenChar(63);
|
||||
}
|
||||
if (node.definite) {
|
||||
this.tokenChar(33);
|
||||
}
|
||||
this.print(node.typeAnnotation);
|
||||
if (node.value) {
|
||||
this.space();
|
||||
this.tokenChar(61);
|
||||
this.space();
|
||||
this.print(node.value);
|
||||
}
|
||||
this.semicolon();
|
||||
}
|
||||
function ClassPrivateProperty(node) {
|
||||
this.printJoin(node.decorators);
|
||||
this.tsPrintClassMemberModifiers(node);
|
||||
this.print(node.key);
|
||||
if (node.optional) {
|
||||
this.tokenChar(63);
|
||||
}
|
||||
if (node.definite) {
|
||||
this.tokenChar(33);
|
||||
}
|
||||
this.print(node.typeAnnotation);
|
||||
if (node.value) {
|
||||
this.space();
|
||||
this.tokenChar(61);
|
||||
this.space();
|
||||
this.print(node.value);
|
||||
}
|
||||
this.semicolon();
|
||||
}
|
||||
function ClassMethod(node) {
|
||||
this._classMethodHead(node);
|
||||
this.space();
|
||||
this.print(node.body);
|
||||
}
|
||||
function ClassPrivateMethod(node) {
|
||||
this._classMethodHead(node);
|
||||
this.space();
|
||||
this.print(node.body);
|
||||
}
|
||||
function _classMethodHead(node) {
|
||||
this.printJoin(node.decorators);
|
||||
if (!this.format.preserveFormat) {
|
||||
var _node$key$loc3;
|
||||
const endLine = (_node$key$loc3 = node.key.loc) == null || (_node$key$loc3 = _node$key$loc3.end) == null ? void 0 : _node$key$loc3.line;
|
||||
if (endLine) this.catchUp(endLine);
|
||||
}
|
||||
this.tsPrintClassMemberModifiers(node);
|
||||
this._methodHead(node);
|
||||
}
|
||||
function StaticBlock(node) {
|
||||
this.word("static");
|
||||
this.space();
|
||||
this.tokenChar(123);
|
||||
if (node.body.length === 0) {
|
||||
this.tokenChar(125);
|
||||
} else {
|
||||
this.newline();
|
||||
this.printSequence(node.body, true);
|
||||
this.rightBrace(node);
|
||||
}
|
||||
}
|
||||
|
||||
//# sourceMappingURL=classes.js.map
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"names":["_index","require","validate","node","key","val","fields","NODE_FIELDS","type","field","validateField","validateChild","validateInternal","maybeNode","optional","_NODE_PARENT_VALIDATI","NODE_PARENT_VALIDATIONS","call","_NODE_PARENT_VALIDATI2"],"sources":["../../src/validators/validate.ts"],"sourcesContent":["import {\n NODE_FIELDS,\n NODE_PARENT_VALIDATIONS,\n type FieldOptions,\n} from \"../definitions/index.ts\";\nimport type * as t from \"../index.ts\";\n\nexport default function validate(\n node: t.Node | undefined | null,\n key: string,\n val: unknown,\n): void {\n if (!node) return;\n\n const fields = NODE_FIELDS[node.type];\n if (!fields) return;\n\n const field = fields[key];\n validateField(node, key, val, field);\n validateChild(node, key, val);\n}\n\nexport function validateInternal(\n field: FieldOptions,\n node: t.Node | undefined | null,\n key: string,\n val: unknown,\n maybeNode?: 1,\n): void {\n if (!field?.validate) return;\n if (field.optional && val == null) return;\n\n field.validate(node, key, val);\n\n if (maybeNode) {\n const type = (val as t.Node).type;\n if (type == null) return;\n NODE_PARENT_VALIDATIONS[type]?.(node, key, val);\n }\n}\n\nexport function validateField(\n node: t.Node | undefined | null,\n key: string,\n val: unknown,\n field: FieldOptions | undefined | null,\n): void {\n if (!field?.validate) return;\n if (field.optional && val == null) return;\n\n field.validate(node, key, val);\n}\n\nexport function validateChild(\n node: t.Node | undefined | null,\n key: string | { toString(): string },\n val?: unknown,\n) {\n const type = (val as t.Node)?.type;\n if (type == null) return;\n NODE_PARENT_VALIDATIONS[type]?.(node, key, val);\n}\n"],"mappings":";;;;;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAOe,SAASC,QAAQA,CAC9BC,IAA+B,EAC/BC,GAAW,EACXC,GAAY,EACN;EACN,IAAI,CAACF,IAAI,EAAE;EAEX,MAAMG,MAAM,GAAGC,kBAAW,CAACJ,IAAI,CAACK,IAAI,CAAC;EACrC,IAAI,CAACF,MAAM,EAAE;EAEb,MAAMG,KAAK,GAAGH,MAAM,CAACF,GAAG,CAAC;EACzBM,aAAa,CAACP,IAAI,EAAEC,GAAG,EAAEC,GAAG,EAAEI,KAAK,CAAC;EACpCE,aAAa,CAACR,IAAI,EAAEC,GAAG,EAAEC,GAAG,CAAC;AAC/B;AAEO,SAASO,gBAAgBA,CAC9BH,KAAmB,EACnBN,IAA+B,EAC/BC,GAAW,EACXC,GAAY,EACZQ,SAAa,EACP;EACN,IAAI,EAACJ,KAAK,YAALA,KAAK,CAAEP,QAAQ,GAAE;EACtB,IAAIO,KAAK,CAACK,QAAQ,IAAIT,GAAG,IAAI,IAAI,EAAE;EAEnCI,KAAK,CAACP,QAAQ,CAACC,IAAI,EAAEC,GAAG,EAAEC,GAAG,CAAC;EAE9B,IAAIQ,SAAS,EAAE;IAAA,IAAAE,qBAAA;IACb,MAAMP,IAAI,GAAIH,GAAG,CAAYG,IAAI;IACjC,IAAIA,IAAI,IAAI,IAAI,EAAE;IAClB,CAAAO,qBAAA,GAAAC,8BAAuB,CAACR,IAAI,CAAC,aAA7BO,qBAAA,CAAAE,IAAA,CAAAD,8BAAuB,EAASb,IAAI,EAAEC,GAAG,EAAEC,GAAG,CAAC;EACjD;AACF;AAEO,SAASK,aAAaA,CAC3BP,IAA+B,EAC/BC,GAAW,EACXC,GAAY,EACZI,KAAsC,EAChC;EACN,IAAI,EAACA,KAAK,YAALA,KAAK,CAAEP,QAAQ,GAAE;EACtB,IAAIO,KAAK,CAACK,QAAQ,IAAIT,GAAG,IAAI,IAAI,EAAE;EAEnCI,KAAK,CAACP,QAAQ,CAACC,IAAI,EAAEC,GAAG,EAAEC,GAAG,CAAC;AAChC;AAEO,SAASM,aAAaA,CAC3BR,IAA+B,EAC/BC,GAAoC,EACpCC,GAAa,EACb;EAAA,IAAAa,sBAAA;EACA,MAAMV,IAAI,GAAIH,GAAG,oBAAHA,GAAG,CAAaG,IAAI;EAClC,IAAIA,IAAI,IAAI,IAAI,EAAE;EAClB,CAAAU,sBAAA,GAAAF,8BAAuB,CAACR,IAAI,CAAC,aAA7BU,sBAAA,CAAAD,IAAA,CAAAD,8BAAuB,EAASb,IAAI,EAAEC,GAAG,EAAEC,GAAG,CAAC;AACjD","ignoreList":[]}
|
||||
@@ -0,0 +1,55 @@
|
||||
{
|
||||
"name": "warning",
|
||||
"version": "4.0.3",
|
||||
"description": "A mirror of Facebook's Warning",
|
||||
"main": "warning.js",
|
||||
"scripts": {
|
||||
"test": "npm run test:dev && npm run test:prod",
|
||||
"test:dev": "NODE_ENV=development jest",
|
||||
"test:prod": "NODE_ENV=production jest",
|
||||
"commit": "git cz",
|
||||
"commitmsg": "commitlint -e $GIT_PARAMS"
|
||||
},
|
||||
"dependencies": {
|
||||
"loose-envify": "^1.0.0"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@commitlint/cli": "^6.2.0",
|
||||
"@commitlint/config-conventional": "^6.1.3",
|
||||
"browserify": "^16.2.2",
|
||||
"commitizen": "^2.10.1",
|
||||
"cz-conventional-changelog": "^2.1.0",
|
||||
"husky": "^0.14.3",
|
||||
"jest": "^23.1.0",
|
||||
"uglify-js": "^3.3.25"
|
||||
},
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "https://github.com/BerkeleyTrue/warning.git"
|
||||
},
|
||||
"config": {
|
||||
"commitizen": {
|
||||
"path": "cz-conventional-changelog"
|
||||
}
|
||||
},
|
||||
"browserify": {
|
||||
"transform": [
|
||||
"loose-envify"
|
||||
]
|
||||
},
|
||||
"files": [
|
||||
"warning.js"
|
||||
],
|
||||
"keywords": [
|
||||
"warning",
|
||||
"facebook",
|
||||
"react",
|
||||
"invariant"
|
||||
],
|
||||
"author": "Berkeley Martinez <berkeley@berkeleytrue.com> (http://www.berkeleytrue.com)",
|
||||
"license": "MIT",
|
||||
"bugs": {
|
||||
"url": "https://github.com/BerkeleyTrue/warning/issues"
|
||||
},
|
||||
"homepage": "https://github.com/BerkeleyTrue/warning"
|
||||
}
|
||||
@@ -0,0 +1,42 @@
|
||||
export class FontFaceObject {
|
||||
constructor(translatedData: any, { disableFontFace, inspectFont }: {
|
||||
disableFontFace?: boolean | undefined;
|
||||
inspectFont?: null | undefined;
|
||||
});
|
||||
compiledGlyphs: any;
|
||||
disableFontFace: boolean;
|
||||
_inspectFont: any;
|
||||
createNativeFontFace(): FontFace | null;
|
||||
createFontFaceRule(): string | null;
|
||||
getPathGenerator(objs: any, character: any): any;
|
||||
}
|
||||
export class FontLoader {
|
||||
constructor({ ownerDocument, styleElement, }: {
|
||||
ownerDocument?: Document | undefined;
|
||||
styleElement?: null | undefined;
|
||||
});
|
||||
_document: Document;
|
||||
nativeFontFaces: Set<any>;
|
||||
styleElement: HTMLStyleElement | null;
|
||||
loadingRequests: any[] | undefined;
|
||||
loadTestFontId: number | undefined;
|
||||
addNativeFontFace(nativeFontFace: any): void;
|
||||
removeNativeFontFace(nativeFontFace: any): void;
|
||||
insertRule(rule: any): void;
|
||||
clear(): void;
|
||||
loadSystemFont({ systemFontInfo: info, _inspectFont }: {
|
||||
systemFontInfo: any;
|
||||
_inspectFont: any;
|
||||
}): Promise<void>;
|
||||
bind(font: any): Promise<void>;
|
||||
get isFontLoadingAPISupported(): any;
|
||||
get isSyncFontLoadingSupported(): any;
|
||||
_queueLoadingCallback(callback: any): {
|
||||
done: boolean;
|
||||
complete: () => void;
|
||||
callback: any;
|
||||
};
|
||||
get _loadTestFont(): any;
|
||||
_prepareFontLoadEvent(font: any, request: any): void;
|
||||
#private;
|
||||
}
|
||||
@@ -0,0 +1,59 @@
|
||||
// From pdfjs-dist/lib/web/struct_tree_layer_builder.js
|
||||
|
||||
export const PDF_ROLE_TO_HTML_ROLE = {
|
||||
// Document level structure types
|
||||
Document: null, // There's a "document" role, but it doesn't make sense here.
|
||||
DocumentFragment: null,
|
||||
// Grouping level structure types
|
||||
Part: 'group',
|
||||
Sect: 'group', // XXX: There's a "section" role, but it's abstract.
|
||||
Div: 'group',
|
||||
Aside: 'note',
|
||||
NonStruct: 'none',
|
||||
// Block level structure types
|
||||
P: null,
|
||||
// H<n>,
|
||||
H: 'heading',
|
||||
Title: null,
|
||||
FENote: 'note',
|
||||
// Sub-block level structure type
|
||||
Sub: 'group',
|
||||
// General inline level structure types
|
||||
Lbl: null,
|
||||
Span: null,
|
||||
Em: null,
|
||||
Strong: null,
|
||||
Link: 'link',
|
||||
Annot: 'note',
|
||||
Form: 'form',
|
||||
// Ruby and Warichu structure types
|
||||
Ruby: null,
|
||||
RB: null,
|
||||
RT: null,
|
||||
RP: null,
|
||||
Warichu: null,
|
||||
WT: null,
|
||||
WP: null,
|
||||
// List standard structure types
|
||||
L: 'list',
|
||||
LI: 'listitem',
|
||||
LBody: null,
|
||||
// Table standard structure types
|
||||
Table: 'table',
|
||||
TR: 'row',
|
||||
TH: 'columnheader',
|
||||
TD: 'cell',
|
||||
THead: 'columnheader',
|
||||
TBody: null,
|
||||
TFoot: null,
|
||||
// Standard structure type Caption
|
||||
Caption: null,
|
||||
// Standard structure type Figure
|
||||
Figure: 'figure',
|
||||
// Standard structure type Formula
|
||||
Formula: null,
|
||||
// standard structure type Artifact
|
||||
Artifact: null,
|
||||
};
|
||||
|
||||
export const HEADING_PATTERN: RegExp = /^H(\d+)$/;
|
||||
@@ -0,0 +1,43 @@
|
||||
{
|
||||
"name": "@babel/helper-compilation-targets",
|
||||
"version": "7.27.0",
|
||||
"author": "The Babel Team (https://babel.dev/team)",
|
||||
"license": "MIT",
|
||||
"description": "Helper functions on Babel compilation targets",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "https://github.com/babel/babel.git",
|
||||
"directory": "packages/babel-helper-compilation-targets"
|
||||
},
|
||||
"main": "./lib/index.js",
|
||||
"exports": {
|
||||
".": {
|
||||
"types": "./lib/index.d.ts",
|
||||
"default": "./lib/index.js"
|
||||
},
|
||||
"./package.json": "./package.json"
|
||||
},
|
||||
"publishConfig": {
|
||||
"access": "public"
|
||||
},
|
||||
"keywords": [
|
||||
"babel",
|
||||
"babel-plugin"
|
||||
],
|
||||
"dependencies": {
|
||||
"@babel/compat-data": "^7.26.8",
|
||||
"@babel/helper-validator-option": "^7.25.9",
|
||||
"browserslist": "^4.24.0",
|
||||
"lru-cache": "^5.1.1",
|
||||
"semver": "^6.3.1"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@babel/helper-plugin-test-runner": "^7.25.9",
|
||||
"@types/lru-cache": "^5.1.1",
|
||||
"@types/semver": "^5.5.0"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=6.9.0"
|
||||
},
|
||||
"type": "commonjs"
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
var test = require('tape');
|
||||
var equal = require('../');
|
||||
|
||||
test('NaN and 0 values', function (t) {
|
||||
t.ok(equal(NaN, NaN));
|
||||
t.notOk(equal(0, NaN));
|
||||
t.ok(equal(0, 0));
|
||||
t.notOk(equal(0, 1));
|
||||
t.end();
|
||||
});
|
||||
|
||||
|
||||
test('nested NaN values', function (t) {
|
||||
t.ok(equal([ NaN, 1, NaN ], [ NaN, 1, NaN ]));
|
||||
t.end();
|
||||
});
|
||||
@@ -0,0 +1,137 @@
|
||||
/**
|
||||
* @fileoverview Rule to check for "block scoped" variables by binding context
|
||||
* @author Matt DuVall <http://www.mattduvall.com>
|
||||
*/
|
||||
"use strict";
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Rule Definition
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/** @type {import('../shared/types').Rule} */
|
||||
module.exports = {
|
||||
meta: {
|
||||
type: "suggestion",
|
||||
|
||||
docs: {
|
||||
description:
|
||||
"Enforce the use of variables within the scope they are defined",
|
||||
recommended: false,
|
||||
url: "https://eslint.org/docs/latest/rules/block-scoped-var",
|
||||
},
|
||||
|
||||
schema: [],
|
||||
|
||||
messages: {
|
||||
outOfScope:
|
||||
"'{{name}}' declared on line {{definitionLine}} column {{definitionColumn}} is used outside of binding context.",
|
||||
},
|
||||
},
|
||||
|
||||
create(context) {
|
||||
let stack = [];
|
||||
const sourceCode = context.sourceCode;
|
||||
|
||||
/**
|
||||
* Makes a block scope.
|
||||
* @param {ASTNode} node A node of a scope.
|
||||
* @returns {void}
|
||||
*/
|
||||
function enterScope(node) {
|
||||
stack.push(node.range);
|
||||
}
|
||||
|
||||
/**
|
||||
* Pops the last block scope.
|
||||
* @returns {void}
|
||||
*/
|
||||
function exitScope() {
|
||||
stack.pop();
|
||||
}
|
||||
|
||||
/**
|
||||
* Reports a given reference.
|
||||
* @param {eslint-scope.Reference} reference A reference to report.
|
||||
* @param {eslint-scope.Definition} definition A definition for which to report reference.
|
||||
* @returns {void}
|
||||
*/
|
||||
function report(reference, definition) {
|
||||
const identifier = reference.identifier;
|
||||
const definitionPosition = definition.name.loc.start;
|
||||
|
||||
context.report({
|
||||
node: identifier,
|
||||
messageId: "outOfScope",
|
||||
data: {
|
||||
name: identifier.name,
|
||||
definitionLine: definitionPosition.line,
|
||||
definitionColumn: definitionPosition.column + 1,
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Finds and reports references which are outside of valid scopes.
|
||||
* @param {ASTNode} node A node to get variables.
|
||||
* @returns {void}
|
||||
*/
|
||||
function checkForVariables(node) {
|
||||
if (node.kind !== "var") {
|
||||
return;
|
||||
}
|
||||
|
||||
// Defines a predicate to check whether or not a given reference is outside of valid scope.
|
||||
const scopeRange = stack.at(-1);
|
||||
|
||||
/**
|
||||
* Check if a reference is out of scope
|
||||
* @param {ASTNode} reference node to examine
|
||||
* @returns {boolean} True is its outside the scope
|
||||
* @private
|
||||
*/
|
||||
function isOutsideOfScope(reference) {
|
||||
const idRange = reference.identifier.range;
|
||||
|
||||
return idRange[0] < scopeRange[0] || idRange[1] > scopeRange[1];
|
||||
}
|
||||
|
||||
// Gets declared variables, and checks its references.
|
||||
const variables = sourceCode.getDeclaredVariables(node);
|
||||
|
||||
for (let i = 0; i < variables.length; ++i) {
|
||||
// Reports.
|
||||
variables[i].references.filter(isOutsideOfScope).forEach(ref =>
|
||||
report(
|
||||
ref,
|
||||
variables[i].defs.find(def => def.parent === node),
|
||||
),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
Program(node) {
|
||||
stack = [node.range];
|
||||
},
|
||||
|
||||
// Manages scopes.
|
||||
BlockStatement: enterScope,
|
||||
"BlockStatement:exit": exitScope,
|
||||
ForStatement: enterScope,
|
||||
"ForStatement:exit": exitScope,
|
||||
ForInStatement: enterScope,
|
||||
"ForInStatement:exit": exitScope,
|
||||
ForOfStatement: enterScope,
|
||||
"ForOfStatement:exit": exitScope,
|
||||
SwitchStatement: enterScope,
|
||||
"SwitchStatement:exit": exitScope,
|
||||
CatchClause: enterScope,
|
||||
"CatchClause:exit": exitScope,
|
||||
StaticBlock: enterScope,
|
||||
"StaticBlock:exit": exitScope,
|
||||
|
||||
// Finds and reports references which are outside of valid scope.
|
||||
VariableDeclaration: checkForVariables,
|
||||
};
|
||||
},
|
||||
};
|
||||
@@ -0,0 +1,608 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.arrowFunctionToExpression = arrowFunctionToExpression;
|
||||
exports.ensureBlock = ensureBlock;
|
||||
exports.ensureFunctionName = ensureFunctionName;
|
||||
exports.splitExportDeclaration = splitExportDeclaration;
|
||||
exports.toComputedKey = toComputedKey;
|
||||
exports.unwrapFunctionEnvironment = unwrapFunctionEnvironment;
|
||||
var _t = require("@babel/types");
|
||||
var _template = require("@babel/template");
|
||||
var _visitors = require("../visitors.js");
|
||||
var _context = require("./context.js");
|
||||
const {
|
||||
arrowFunctionExpression,
|
||||
assignmentExpression,
|
||||
binaryExpression,
|
||||
blockStatement,
|
||||
callExpression,
|
||||
conditionalExpression,
|
||||
expressionStatement,
|
||||
identifier,
|
||||
isIdentifier,
|
||||
jsxIdentifier,
|
||||
logicalExpression,
|
||||
LOGICAL_OPERATORS,
|
||||
memberExpression,
|
||||
metaProperty,
|
||||
numericLiteral,
|
||||
objectExpression,
|
||||
restElement,
|
||||
returnStatement,
|
||||
sequenceExpression,
|
||||
spreadElement,
|
||||
stringLiteral,
|
||||
super: _super,
|
||||
thisExpression,
|
||||
toExpression,
|
||||
unaryExpression,
|
||||
toBindingIdentifierName,
|
||||
isFunction,
|
||||
isAssignmentPattern,
|
||||
isRestElement,
|
||||
getFunctionName,
|
||||
cloneNode,
|
||||
variableDeclaration,
|
||||
variableDeclarator,
|
||||
exportNamedDeclaration,
|
||||
exportSpecifier,
|
||||
inherits
|
||||
} = _t;
|
||||
function toComputedKey() {
|
||||
let key;
|
||||
if (this.isMemberExpression()) {
|
||||
key = this.node.property;
|
||||
} else if (this.isProperty() || this.isMethod()) {
|
||||
key = this.node.key;
|
||||
} else {
|
||||
throw new ReferenceError("todo");
|
||||
}
|
||||
if (!this.node.computed) {
|
||||
if (isIdentifier(key)) key = stringLiteral(key.name);
|
||||
}
|
||||
return key;
|
||||
}
|
||||
function ensureBlock() {
|
||||
const body = this.get("body");
|
||||
const bodyNode = body.node;
|
||||
if (Array.isArray(body)) {
|
||||
throw new Error("Can't convert array path to a block statement");
|
||||
}
|
||||
if (!bodyNode) {
|
||||
throw new Error("Can't convert node without a body");
|
||||
}
|
||||
if (body.isBlockStatement()) {
|
||||
return bodyNode;
|
||||
}
|
||||
const statements = [];
|
||||
let stringPath = "body";
|
||||
let key;
|
||||
let listKey;
|
||||
if (body.isStatement()) {
|
||||
listKey = "body";
|
||||
key = 0;
|
||||
statements.push(body.node);
|
||||
} else {
|
||||
stringPath += ".body.0";
|
||||
if (this.isFunction()) {
|
||||
key = "argument";
|
||||
statements.push(returnStatement(body.node));
|
||||
} else {
|
||||
key = "expression";
|
||||
statements.push(expressionStatement(body.node));
|
||||
}
|
||||
}
|
||||
this.node.body = blockStatement(statements);
|
||||
const parentPath = this.get(stringPath);
|
||||
_context.setup.call(body, parentPath, listKey ? parentPath.node[listKey] : parentPath.node, listKey, key);
|
||||
return this.node;
|
||||
}
|
||||
{
|
||||
exports.arrowFunctionToShadowed = function () {
|
||||
if (!this.isArrowFunctionExpression()) return;
|
||||
this.arrowFunctionToExpression();
|
||||
};
|
||||
}
|
||||
function unwrapFunctionEnvironment() {
|
||||
if (!this.isArrowFunctionExpression() && !this.isFunctionExpression() && !this.isFunctionDeclaration()) {
|
||||
throw this.buildCodeFrameError("Can only unwrap the environment of a function.");
|
||||
}
|
||||
hoistFunctionEnvironment(this);
|
||||
}
|
||||
function setType(path, type) {
|
||||
path.node.type = type;
|
||||
}
|
||||
function arrowFunctionToExpression({
|
||||
allowInsertArrow = true,
|
||||
allowInsertArrowWithRest = allowInsertArrow,
|
||||
noNewArrows = !(_arguments$ => (_arguments$ = arguments[0]) == null ? void 0 : _arguments$.specCompliant)()
|
||||
} = {}) {
|
||||
if (!this.isArrowFunctionExpression()) {
|
||||
throw this.buildCodeFrameError("Cannot convert non-arrow function to a function expression.");
|
||||
}
|
||||
let self = this;
|
||||
if (!noNewArrows) {
|
||||
var _self$ensureFunctionN;
|
||||
self = (_self$ensureFunctionN = self.ensureFunctionName(false)) != null ? _self$ensureFunctionN : self;
|
||||
}
|
||||
const {
|
||||
thisBinding,
|
||||
fnPath: fn
|
||||
} = hoistFunctionEnvironment(self, noNewArrows, allowInsertArrow, allowInsertArrowWithRest);
|
||||
fn.ensureBlock();
|
||||
setType(fn, "FunctionExpression");
|
||||
if (!noNewArrows) {
|
||||
const checkBinding = thisBinding ? null : fn.scope.generateUidIdentifier("arrowCheckId");
|
||||
if (checkBinding) {
|
||||
fn.parentPath.scope.push({
|
||||
id: checkBinding,
|
||||
init: objectExpression([])
|
||||
});
|
||||
}
|
||||
fn.get("body").unshiftContainer("body", expressionStatement(callExpression(this.hub.addHelper("newArrowCheck"), [thisExpression(), checkBinding ? identifier(checkBinding.name) : identifier(thisBinding)])));
|
||||
fn.replaceWith(callExpression(memberExpression(fn.node, identifier("bind")), [checkBinding ? identifier(checkBinding.name) : thisExpression()]));
|
||||
return fn.get("callee.object");
|
||||
}
|
||||
return fn;
|
||||
}
|
||||
const getSuperCallsVisitor = (0, _visitors.environmentVisitor)({
|
||||
CallExpression(child, {
|
||||
allSuperCalls
|
||||
}) {
|
||||
if (!child.get("callee").isSuper()) return;
|
||||
allSuperCalls.push(child);
|
||||
}
|
||||
});
|
||||
function hoistFunctionEnvironment(fnPath, noNewArrows = true, allowInsertArrow = true, allowInsertArrowWithRest = true) {
|
||||
let arrowParent;
|
||||
let thisEnvFn = fnPath.findParent(p => {
|
||||
if (p.isArrowFunctionExpression()) {
|
||||
arrowParent != null ? arrowParent : arrowParent = p;
|
||||
return false;
|
||||
}
|
||||
return p.isFunction() || p.isProgram() || p.isClassProperty({
|
||||
static: false
|
||||
}) || p.isClassPrivateProperty({
|
||||
static: false
|
||||
});
|
||||
});
|
||||
const inConstructor = thisEnvFn.isClassMethod({
|
||||
kind: "constructor"
|
||||
});
|
||||
if (thisEnvFn.isClassProperty() || thisEnvFn.isClassPrivateProperty()) {
|
||||
if (arrowParent) {
|
||||
thisEnvFn = arrowParent;
|
||||
} else if (allowInsertArrow) {
|
||||
fnPath.replaceWith(callExpression(arrowFunctionExpression([], toExpression(fnPath.node)), []));
|
||||
thisEnvFn = fnPath.get("callee");
|
||||
fnPath = thisEnvFn.get("body");
|
||||
} else {
|
||||
throw fnPath.buildCodeFrameError("Unable to transform arrow inside class property");
|
||||
}
|
||||
}
|
||||
const {
|
||||
thisPaths,
|
||||
argumentsPaths,
|
||||
newTargetPaths,
|
||||
superProps,
|
||||
superCalls
|
||||
} = getScopeInformation(fnPath);
|
||||
if (inConstructor && superCalls.length > 0) {
|
||||
if (!allowInsertArrow) {
|
||||
throw superCalls[0].buildCodeFrameError("When using '@babel/plugin-transform-arrow-functions', " + "it's not possible to compile `super()` in an arrow function without compiling classes.\n" + "Please add '@babel/plugin-transform-classes' to your Babel configuration.");
|
||||
}
|
||||
if (!allowInsertArrowWithRest) {
|
||||
throw superCalls[0].buildCodeFrameError("When using '@babel/plugin-transform-parameters', " + "it's not possible to compile `super()` in an arrow function with default or rest parameters without compiling classes.\n" + "Please add '@babel/plugin-transform-classes' to your Babel configuration.");
|
||||
}
|
||||
const allSuperCalls = [];
|
||||
thisEnvFn.traverse(getSuperCallsVisitor, {
|
||||
allSuperCalls
|
||||
});
|
||||
const superBinding = getSuperBinding(thisEnvFn);
|
||||
allSuperCalls.forEach(superCall => {
|
||||
const callee = identifier(superBinding);
|
||||
callee.loc = superCall.node.callee.loc;
|
||||
superCall.get("callee").replaceWith(callee);
|
||||
});
|
||||
}
|
||||
if (argumentsPaths.length > 0) {
|
||||
const argumentsBinding = getBinding(thisEnvFn, "arguments", () => {
|
||||
const args = () => identifier("arguments");
|
||||
if (thisEnvFn.scope.path.isProgram()) {
|
||||
return conditionalExpression(binaryExpression("===", unaryExpression("typeof", args()), stringLiteral("undefined")), thisEnvFn.scope.buildUndefinedNode(), args());
|
||||
} else {
|
||||
return args();
|
||||
}
|
||||
});
|
||||
argumentsPaths.forEach(argumentsChild => {
|
||||
const argsRef = identifier(argumentsBinding);
|
||||
argsRef.loc = argumentsChild.node.loc;
|
||||
argumentsChild.replaceWith(argsRef);
|
||||
});
|
||||
}
|
||||
if (newTargetPaths.length > 0) {
|
||||
const newTargetBinding = getBinding(thisEnvFn, "newtarget", () => metaProperty(identifier("new"), identifier("target")));
|
||||
newTargetPaths.forEach(targetChild => {
|
||||
const targetRef = identifier(newTargetBinding);
|
||||
targetRef.loc = targetChild.node.loc;
|
||||
targetChild.replaceWith(targetRef);
|
||||
});
|
||||
}
|
||||
if (superProps.length > 0) {
|
||||
if (!allowInsertArrow) {
|
||||
throw superProps[0].buildCodeFrameError("When using '@babel/plugin-transform-arrow-functions', " + "it's not possible to compile `super.prop` in an arrow function without compiling classes.\n" + "Please add '@babel/plugin-transform-classes' to your Babel configuration.");
|
||||
}
|
||||
const flatSuperProps = superProps.reduce((acc, superProp) => acc.concat(standardizeSuperProperty(superProp)), []);
|
||||
flatSuperProps.forEach(superProp => {
|
||||
const key = superProp.node.computed ? "" : superProp.get("property").node.name;
|
||||
const superParentPath = superProp.parentPath;
|
||||
const isAssignment = superParentPath.isAssignmentExpression({
|
||||
left: superProp.node
|
||||
});
|
||||
const isCall = superParentPath.isCallExpression({
|
||||
callee: superProp.node
|
||||
});
|
||||
const isTaggedTemplate = superParentPath.isTaggedTemplateExpression({
|
||||
tag: superProp.node
|
||||
});
|
||||
const superBinding = getSuperPropBinding(thisEnvFn, isAssignment, key);
|
||||
const args = [];
|
||||
if (superProp.node.computed) {
|
||||
args.push(superProp.get("property").node);
|
||||
}
|
||||
if (isAssignment) {
|
||||
const value = superParentPath.node.right;
|
||||
args.push(value);
|
||||
}
|
||||
const call = callExpression(identifier(superBinding), args);
|
||||
if (isCall) {
|
||||
superParentPath.unshiftContainer("arguments", thisExpression());
|
||||
superProp.replaceWith(memberExpression(call, identifier("call")));
|
||||
thisPaths.push(superParentPath.get("arguments.0"));
|
||||
} else if (isAssignment) {
|
||||
superParentPath.replaceWith(call);
|
||||
} else if (isTaggedTemplate) {
|
||||
superProp.replaceWith(callExpression(memberExpression(call, identifier("bind"), false), [thisExpression()]));
|
||||
thisPaths.push(superProp.get("arguments.0"));
|
||||
} else {
|
||||
superProp.replaceWith(call);
|
||||
}
|
||||
});
|
||||
}
|
||||
let thisBinding;
|
||||
if (thisPaths.length > 0 || !noNewArrows) {
|
||||
thisBinding = getThisBinding(thisEnvFn, inConstructor);
|
||||
if (noNewArrows || inConstructor && hasSuperClass(thisEnvFn)) {
|
||||
thisPaths.forEach(thisChild => {
|
||||
const thisRef = thisChild.isJSX() ? jsxIdentifier(thisBinding) : identifier(thisBinding);
|
||||
thisRef.loc = thisChild.node.loc;
|
||||
thisChild.replaceWith(thisRef);
|
||||
});
|
||||
if (!noNewArrows) thisBinding = null;
|
||||
}
|
||||
}
|
||||
return {
|
||||
thisBinding,
|
||||
fnPath
|
||||
};
|
||||
}
|
||||
function isLogicalOp(op) {
|
||||
return LOGICAL_OPERATORS.includes(op);
|
||||
}
|
||||
function standardizeSuperProperty(superProp) {
|
||||
if (superProp.parentPath.isAssignmentExpression() && superProp.parentPath.node.operator !== "=") {
|
||||
const assignmentPath = superProp.parentPath;
|
||||
const op = assignmentPath.node.operator.slice(0, -1);
|
||||
const value = assignmentPath.node.right;
|
||||
const isLogicalAssignment = isLogicalOp(op);
|
||||
if (superProp.node.computed) {
|
||||
const tmp = superProp.scope.generateDeclaredUidIdentifier("tmp");
|
||||
const object = superProp.node.object;
|
||||
const property = superProp.node.property;
|
||||
assignmentPath.get("left").replaceWith(memberExpression(object, assignmentExpression("=", tmp, property), true));
|
||||
assignmentPath.get("right").replaceWith(rightExpression(isLogicalAssignment ? "=" : op, memberExpression(object, identifier(tmp.name), true), value));
|
||||
} else {
|
||||
const object = superProp.node.object;
|
||||
const property = superProp.node.property;
|
||||
assignmentPath.get("left").replaceWith(memberExpression(object, property));
|
||||
assignmentPath.get("right").replaceWith(rightExpression(isLogicalAssignment ? "=" : op, memberExpression(object, identifier(property.name)), value));
|
||||
}
|
||||
if (isLogicalAssignment) {
|
||||
assignmentPath.replaceWith(logicalExpression(op, assignmentPath.node.left, assignmentPath.node.right));
|
||||
} else {
|
||||
assignmentPath.node.operator = "=";
|
||||
}
|
||||
return [assignmentPath.get("left"), assignmentPath.get("right").get("left")];
|
||||
} else if (superProp.parentPath.isUpdateExpression()) {
|
||||
const updateExpr = superProp.parentPath;
|
||||
const tmp = superProp.scope.generateDeclaredUidIdentifier("tmp");
|
||||
const computedKey = superProp.node.computed ? superProp.scope.generateDeclaredUidIdentifier("prop") : null;
|
||||
const parts = [assignmentExpression("=", tmp, memberExpression(superProp.node.object, computedKey ? assignmentExpression("=", computedKey, superProp.node.property) : superProp.node.property, superProp.node.computed)), assignmentExpression("=", memberExpression(superProp.node.object, computedKey ? identifier(computedKey.name) : superProp.node.property, superProp.node.computed), binaryExpression(superProp.parentPath.node.operator[0], identifier(tmp.name), numericLiteral(1)))];
|
||||
if (!superProp.parentPath.node.prefix) {
|
||||
parts.push(identifier(tmp.name));
|
||||
}
|
||||
updateExpr.replaceWith(sequenceExpression(parts));
|
||||
const left = updateExpr.get("expressions.0.right");
|
||||
const right = updateExpr.get("expressions.1.left");
|
||||
return [left, right];
|
||||
}
|
||||
return [superProp];
|
||||
function rightExpression(op, left, right) {
|
||||
if (op === "=") {
|
||||
return assignmentExpression("=", left, right);
|
||||
} else {
|
||||
return binaryExpression(op, left, right);
|
||||
}
|
||||
}
|
||||
}
|
||||
function hasSuperClass(thisEnvFn) {
|
||||
return thisEnvFn.isClassMethod() && !!thisEnvFn.parentPath.parentPath.node.superClass;
|
||||
}
|
||||
const assignSuperThisVisitor = (0, _visitors.environmentVisitor)({
|
||||
CallExpression(child, {
|
||||
supers,
|
||||
thisBinding
|
||||
}) {
|
||||
if (!child.get("callee").isSuper()) return;
|
||||
if (supers.has(child.node)) return;
|
||||
supers.add(child.node);
|
||||
child.replaceWithMultiple([child.node, assignmentExpression("=", identifier(thisBinding), identifier("this"))]);
|
||||
}
|
||||
});
|
||||
function getThisBinding(thisEnvFn, inConstructor) {
|
||||
return getBinding(thisEnvFn, "this", thisBinding => {
|
||||
if (!inConstructor || !hasSuperClass(thisEnvFn)) return thisExpression();
|
||||
thisEnvFn.traverse(assignSuperThisVisitor, {
|
||||
supers: new WeakSet(),
|
||||
thisBinding
|
||||
});
|
||||
});
|
||||
}
|
||||
function getSuperBinding(thisEnvFn) {
|
||||
return getBinding(thisEnvFn, "supercall", () => {
|
||||
const argsBinding = thisEnvFn.scope.generateUidIdentifier("args");
|
||||
return arrowFunctionExpression([restElement(argsBinding)], callExpression(_super(), [spreadElement(identifier(argsBinding.name))]));
|
||||
});
|
||||
}
|
||||
function getSuperPropBinding(thisEnvFn, isAssignment, propName) {
|
||||
const op = isAssignment ? "set" : "get";
|
||||
return getBinding(thisEnvFn, `superprop_${op}:${propName || ""}`, () => {
|
||||
const argsList = [];
|
||||
let fnBody;
|
||||
if (propName) {
|
||||
fnBody = memberExpression(_super(), identifier(propName));
|
||||
} else {
|
||||
const method = thisEnvFn.scope.generateUidIdentifier("prop");
|
||||
argsList.unshift(method);
|
||||
fnBody = memberExpression(_super(), identifier(method.name), true);
|
||||
}
|
||||
if (isAssignment) {
|
||||
const valueIdent = thisEnvFn.scope.generateUidIdentifier("value");
|
||||
argsList.push(valueIdent);
|
||||
fnBody = assignmentExpression("=", fnBody, identifier(valueIdent.name));
|
||||
}
|
||||
return arrowFunctionExpression(argsList, fnBody);
|
||||
});
|
||||
}
|
||||
function getBinding(thisEnvFn, key, init) {
|
||||
const cacheKey = "binding:" + key;
|
||||
let data = thisEnvFn.getData(cacheKey);
|
||||
if (!data) {
|
||||
const id = thisEnvFn.scope.generateUidIdentifier(key);
|
||||
data = id.name;
|
||||
thisEnvFn.setData(cacheKey, data);
|
||||
thisEnvFn.scope.push({
|
||||
id: id,
|
||||
init: init(data)
|
||||
});
|
||||
}
|
||||
return data;
|
||||
}
|
||||
const getScopeInformationVisitor = (0, _visitors.environmentVisitor)({
|
||||
ThisExpression(child, {
|
||||
thisPaths
|
||||
}) {
|
||||
thisPaths.push(child);
|
||||
},
|
||||
JSXIdentifier(child, {
|
||||
thisPaths
|
||||
}) {
|
||||
if (child.node.name !== "this") return;
|
||||
if (!child.parentPath.isJSXMemberExpression({
|
||||
object: child.node
|
||||
}) && !child.parentPath.isJSXOpeningElement({
|
||||
name: child.node
|
||||
})) {
|
||||
return;
|
||||
}
|
||||
thisPaths.push(child);
|
||||
},
|
||||
CallExpression(child, {
|
||||
superCalls
|
||||
}) {
|
||||
if (child.get("callee").isSuper()) superCalls.push(child);
|
||||
},
|
||||
MemberExpression(child, {
|
||||
superProps
|
||||
}) {
|
||||
if (child.get("object").isSuper()) superProps.push(child);
|
||||
},
|
||||
Identifier(child, {
|
||||
argumentsPaths
|
||||
}) {
|
||||
if (!child.isReferencedIdentifier({
|
||||
name: "arguments"
|
||||
})) return;
|
||||
let curr = child.scope;
|
||||
do {
|
||||
if (curr.hasOwnBinding("arguments")) {
|
||||
curr.rename("arguments");
|
||||
return;
|
||||
}
|
||||
if (curr.path.isFunction() && !curr.path.isArrowFunctionExpression()) {
|
||||
break;
|
||||
}
|
||||
} while (curr = curr.parent);
|
||||
argumentsPaths.push(child);
|
||||
},
|
||||
MetaProperty(child, {
|
||||
newTargetPaths
|
||||
}) {
|
||||
if (!child.get("meta").isIdentifier({
|
||||
name: "new"
|
||||
})) return;
|
||||
if (!child.get("property").isIdentifier({
|
||||
name: "target"
|
||||
})) return;
|
||||
newTargetPaths.push(child);
|
||||
}
|
||||
});
|
||||
function getScopeInformation(fnPath) {
|
||||
const thisPaths = [];
|
||||
const argumentsPaths = [];
|
||||
const newTargetPaths = [];
|
||||
const superProps = [];
|
||||
const superCalls = [];
|
||||
fnPath.traverse(getScopeInformationVisitor, {
|
||||
thisPaths,
|
||||
argumentsPaths,
|
||||
newTargetPaths,
|
||||
superProps,
|
||||
superCalls
|
||||
});
|
||||
return {
|
||||
thisPaths,
|
||||
argumentsPaths,
|
||||
newTargetPaths,
|
||||
superProps,
|
||||
superCalls
|
||||
};
|
||||
}
|
||||
function splitExportDeclaration() {
|
||||
if (!this.isExportDeclaration() || this.isExportAllDeclaration()) {
|
||||
throw new Error("Only default and named export declarations can be split.");
|
||||
}
|
||||
if (this.isExportNamedDeclaration() && this.get("specifiers").length > 0) {
|
||||
throw new Error("It doesn't make sense to split exported specifiers.");
|
||||
}
|
||||
const declaration = this.get("declaration");
|
||||
if (this.isExportDefaultDeclaration()) {
|
||||
const standaloneDeclaration = declaration.isFunctionDeclaration() || declaration.isClassDeclaration();
|
||||
const exportExpr = declaration.isFunctionExpression() || declaration.isClassExpression();
|
||||
const scope = declaration.isScope() ? declaration.scope.parent : declaration.scope;
|
||||
let id = declaration.node.id;
|
||||
let needBindingRegistration = false;
|
||||
if (!id) {
|
||||
needBindingRegistration = true;
|
||||
id = scope.generateUidIdentifier("default");
|
||||
if (standaloneDeclaration || exportExpr) {
|
||||
declaration.node.id = cloneNode(id);
|
||||
}
|
||||
} else if (exportExpr && scope.hasBinding(id.name)) {
|
||||
needBindingRegistration = true;
|
||||
id = scope.generateUidIdentifier(id.name);
|
||||
}
|
||||
const updatedDeclaration = standaloneDeclaration ? declaration.node : variableDeclaration("var", [variableDeclarator(cloneNode(id), declaration.node)]);
|
||||
const updatedExportDeclaration = exportNamedDeclaration(null, [exportSpecifier(cloneNode(id), identifier("default"))]);
|
||||
this.insertAfter(updatedExportDeclaration);
|
||||
this.replaceWith(updatedDeclaration);
|
||||
if (needBindingRegistration) {
|
||||
scope.registerDeclaration(this);
|
||||
}
|
||||
return this;
|
||||
} else if (this.get("specifiers").length > 0) {
|
||||
throw new Error("It doesn't make sense to split exported specifiers.");
|
||||
}
|
||||
const bindingIdentifiers = declaration.getOuterBindingIdentifiers();
|
||||
const specifiers = Object.keys(bindingIdentifiers).map(name => {
|
||||
return exportSpecifier(identifier(name), identifier(name));
|
||||
});
|
||||
const aliasDeclar = exportNamedDeclaration(null, specifiers);
|
||||
this.insertAfter(aliasDeclar);
|
||||
this.replaceWith(declaration.node);
|
||||
return this;
|
||||
}
|
||||
const refersOuterBindingVisitor = {
|
||||
"ReferencedIdentifier|BindingIdentifier"(path, state) {
|
||||
if (path.node.name !== state.name) return;
|
||||
state.needsRename = true;
|
||||
path.stop();
|
||||
},
|
||||
Scope(path, state) {
|
||||
if (path.scope.hasOwnBinding(state.name)) {
|
||||
path.skip();
|
||||
}
|
||||
}
|
||||
};
|
||||
function ensureFunctionName(supportUnicodeId) {
|
||||
if (this.node.id) return this;
|
||||
const res = getFunctionName(this.node, this.parent);
|
||||
if (res == null) return this;
|
||||
let {
|
||||
name
|
||||
} = res;
|
||||
if (!supportUnicodeId && /[\uD800-\uDFFF]/.test(name)) {
|
||||
return null;
|
||||
}
|
||||
if (name.startsWith("get ") || name.startsWith("set ")) {
|
||||
return null;
|
||||
}
|
||||
name = toBindingIdentifierName(name.replace(/[/ ]/g, "_"));
|
||||
const id = identifier(name);
|
||||
inherits(id, res.originalNode);
|
||||
const state = {
|
||||
needsRename: false,
|
||||
name
|
||||
};
|
||||
const {
|
||||
scope
|
||||
} = this;
|
||||
const binding = scope.getOwnBinding(name);
|
||||
if (binding) {
|
||||
if (binding.kind === "param") {
|
||||
state.needsRename = true;
|
||||
} else {}
|
||||
} else if (scope.parent.hasBinding(name) || scope.hasGlobal(name)) {
|
||||
this.traverse(refersOuterBindingVisitor, state);
|
||||
}
|
||||
if (!state.needsRename) {
|
||||
this.node.id = id;
|
||||
scope.getProgramParent().references[id.name] = true;
|
||||
return this;
|
||||
}
|
||||
if (scope.hasBinding(id.name) && !scope.hasGlobal(id.name)) {
|
||||
scope.rename(id.name);
|
||||
this.node.id = id;
|
||||
scope.getProgramParent().references[id.name] = true;
|
||||
return this;
|
||||
}
|
||||
if (!isFunction(this.node)) return null;
|
||||
const key = scope.generateUidIdentifier(id.name);
|
||||
const params = [];
|
||||
for (let i = 0, len = getFunctionArity(this.node); i < len; i++) {
|
||||
params.push(scope.generateUidIdentifier("x"));
|
||||
}
|
||||
const call = _template.default.expression.ast`
|
||||
(function (${key}) {
|
||||
function ${id}(${params}) {
|
||||
return ${cloneNode(key)}.apply(this, arguments);
|
||||
}
|
||||
|
||||
${cloneNode(id)}.toString = function () {
|
||||
return ${cloneNode(key)}.toString();
|
||||
}
|
||||
|
||||
return ${cloneNode(id)};
|
||||
})(${toExpression(this.node)})
|
||||
`;
|
||||
return this.replaceWith(call)[0].get("arguments.0");
|
||||
}
|
||||
function getFunctionArity(node) {
|
||||
const count = node.params.findIndex(param => isAssignmentPattern(param) || isRestElement(param));
|
||||
return count === -1 ? node.params.length : count;
|
||||
}
|
||||
|
||||
//# sourceMappingURL=conversion.js.map
|
||||
@@ -0,0 +1,34 @@
|
||||
'use strict';
|
||||
|
||||
var parse = require('../');
|
||||
var test = require('tape');
|
||||
|
||||
test('flag boolean true (default all --args to boolean)', function (t) {
|
||||
var argv = parse(['moo', '--honk', 'cow'], {
|
||||
boolean: true,
|
||||
});
|
||||
|
||||
t.deepEqual(argv, {
|
||||
honk: true,
|
||||
_: ['moo', 'cow'],
|
||||
});
|
||||
|
||||
t.deepEqual(typeof argv.honk, 'boolean');
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('flag boolean true only affects double hyphen arguments without equals signs', function (t) {
|
||||
var argv = parse(['moo', '--honk', 'cow', '-p', '55', '--tacos=good'], {
|
||||
boolean: true,
|
||||
});
|
||||
|
||||
t.deepEqual(argv, {
|
||||
honk: true,
|
||||
tacos: 'good',
|
||||
p: 55,
|
||||
_: ['moo', 'cow'],
|
||||
});
|
||||
|
||||
t.deepEqual(typeof argv.honk, 'boolean');
|
||||
t.end();
|
||||
});
|
||||
@@ -0,0 +1,180 @@
|
||||
/**
|
||||
* @fileoverview Rule to flag adding properties to native object's prototypes.
|
||||
* @author David Nelson
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Requirements
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
const astUtils = require("./utils/ast-utils");
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Rule Definition
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/** @type {import('../shared/types').Rule} */
|
||||
module.exports = {
|
||||
meta: {
|
||||
type: "suggestion",
|
||||
|
||||
defaultOptions: [{ exceptions: [] }],
|
||||
|
||||
docs: {
|
||||
description: "Disallow extending native types",
|
||||
recommended: false,
|
||||
url: "https://eslint.org/docs/latest/rules/no-extend-native",
|
||||
},
|
||||
|
||||
schema: [
|
||||
{
|
||||
type: "object",
|
||||
properties: {
|
||||
exceptions: {
|
||||
type: "array",
|
||||
items: {
|
||||
type: "string",
|
||||
},
|
||||
uniqueItems: true,
|
||||
},
|
||||
},
|
||||
additionalProperties: false,
|
||||
},
|
||||
],
|
||||
|
||||
messages: {
|
||||
unexpected:
|
||||
"{{builtin}} prototype is read only, properties should not be added.",
|
||||
},
|
||||
},
|
||||
|
||||
create(context) {
|
||||
const sourceCode = context.sourceCode;
|
||||
const exceptions = new Set(context.options[0].exceptions);
|
||||
const modifiedBuiltins = new Set(
|
||||
Object.keys(astUtils.ECMASCRIPT_GLOBALS)
|
||||
.filter(builtin => builtin[0].toUpperCase() === builtin[0])
|
||||
.filter(builtin => !exceptions.has(builtin)),
|
||||
);
|
||||
|
||||
/**
|
||||
* Reports a lint error for the given node.
|
||||
* @param {ASTNode} node The node to report.
|
||||
* @param {string} builtin The name of the native builtin being extended.
|
||||
* @returns {void}
|
||||
*/
|
||||
function reportNode(node, builtin) {
|
||||
context.report({
|
||||
node,
|
||||
messageId: "unexpected",
|
||||
data: {
|
||||
builtin,
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Check to see if the `prototype` property of the given object
|
||||
* identifier node is being accessed.
|
||||
* @param {ASTNode} identifierNode The Identifier representing the object
|
||||
* to check.
|
||||
* @returns {boolean} True if the identifier is the object of a
|
||||
* MemberExpression and its `prototype` property is being accessed,
|
||||
* false otherwise.
|
||||
*/
|
||||
function isPrototypePropertyAccessed(identifierNode) {
|
||||
return Boolean(
|
||||
identifierNode &&
|
||||
identifierNode.parent &&
|
||||
identifierNode.parent.type === "MemberExpression" &&
|
||||
identifierNode.parent.object === identifierNode &&
|
||||
astUtils.getStaticPropertyName(identifierNode.parent) ===
|
||||
"prototype",
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if it's an assignment to the property of the given node.
|
||||
* Example: `*.prop = 0` // the `*` is the given node.
|
||||
* @param {ASTNode} node The node to check.
|
||||
* @returns {boolean} True if an assignment to the property of the node.
|
||||
*/
|
||||
function isAssigningToPropertyOf(node) {
|
||||
return (
|
||||
node.parent.type === "MemberExpression" &&
|
||||
node.parent.object === node &&
|
||||
node.parent.parent.type === "AssignmentExpression" &&
|
||||
node.parent.parent.left === node.parent
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if the given node is at the first argument of the method call of `Object.defineProperty()` or `Object.defineProperties()`.
|
||||
* @param {ASTNode} node The node to check.
|
||||
* @returns {boolean} True if the node is at the first argument of the method call of `Object.defineProperty()` or `Object.defineProperties()`.
|
||||
*/
|
||||
function isInDefinePropertyCall(node) {
|
||||
return (
|
||||
node.parent.type === "CallExpression" &&
|
||||
node.parent.arguments[0] === node &&
|
||||
astUtils.isSpecificMemberAccess(
|
||||
node.parent.callee,
|
||||
"Object",
|
||||
/^definePropert(?:y|ies)$/u,
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check to see if object prototype access is part of a prototype
|
||||
* extension. There are three ways a prototype can be extended:
|
||||
* 1. Assignment to prototype property (Object.prototype.foo = 1)
|
||||
* 2. Object.defineProperty()/Object.defineProperties() on a prototype
|
||||
* If prototype extension is detected, report the AssignmentExpression
|
||||
* or CallExpression node.
|
||||
* @param {ASTNode} identifierNode The Identifier representing the object
|
||||
* which prototype is being accessed and possibly extended.
|
||||
* @returns {void}
|
||||
*/
|
||||
function checkAndReportPrototypeExtension(identifierNode) {
|
||||
if (!isPrototypePropertyAccessed(identifierNode)) {
|
||||
return; // This is not `*.prototype` access.
|
||||
}
|
||||
|
||||
/*
|
||||
* `identifierNode.parent` is a MemberExpression `*.prototype`.
|
||||
* If it's an optional member access, it may be wrapped by a `ChainExpression` node.
|
||||
*/
|
||||
const prototypeNode =
|
||||
identifierNode.parent.parent.type === "ChainExpression"
|
||||
? identifierNode.parent.parent
|
||||
: identifierNode.parent;
|
||||
|
||||
if (isAssigningToPropertyOf(prototypeNode)) {
|
||||
// `*.prototype` -> MemberExpression -> AssignmentExpression
|
||||
reportNode(prototypeNode.parent.parent, identifierNode.name);
|
||||
} else if (isInDefinePropertyCall(prototypeNode)) {
|
||||
// `*.prototype` -> CallExpression
|
||||
reportNode(prototypeNode.parent, identifierNode.name);
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
"Program:exit"(node) {
|
||||
const globalScope = sourceCode.getScope(node);
|
||||
|
||||
modifiedBuiltins.forEach(builtin => {
|
||||
const builtinVar = globalScope.set.get(builtin);
|
||||
|
||||
if (builtinVar && builtinVar.references) {
|
||||
builtinVar.references
|
||||
.map(ref => ref.identifier)
|
||||
.forEach(checkAndReportPrototypeExtension);
|
||||
}
|
||||
});
|
||||
},
|
||||
};
|
||||
},
|
||||
};
|
||||
@@ -0,0 +1,85 @@
|
||||
/**
|
||||
* @fileoverview Rule to flag references to the undefined variable.
|
||||
* @author Michael Ficarra
|
||||
*/
|
||||
"use strict";
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Rule Definition
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/** @type {import('../shared/types').Rule} */
|
||||
module.exports = {
|
||||
meta: {
|
||||
type: "suggestion",
|
||||
|
||||
docs: {
|
||||
description: "Disallow the use of `undefined` as an identifier",
|
||||
recommended: false,
|
||||
frozen: true,
|
||||
url: "https://eslint.org/docs/latest/rules/no-undefined",
|
||||
},
|
||||
|
||||
schema: [],
|
||||
|
||||
messages: {
|
||||
unexpectedUndefined: "Unexpected use of undefined.",
|
||||
},
|
||||
},
|
||||
|
||||
create(context) {
|
||||
const sourceCode = context.sourceCode;
|
||||
|
||||
/**
|
||||
* Report an invalid "undefined" identifier node.
|
||||
* @param {ASTNode} node The node to report.
|
||||
* @returns {void}
|
||||
*/
|
||||
function report(node) {
|
||||
context.report({
|
||||
node,
|
||||
messageId: "unexpectedUndefined",
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks the given scope for references to `undefined` and reports
|
||||
* all references found.
|
||||
* @param {eslint-scope.Scope} scope The scope to check.
|
||||
* @returns {void}
|
||||
*/
|
||||
function checkScope(scope) {
|
||||
const undefinedVar = scope.set.get("undefined");
|
||||
|
||||
if (!undefinedVar) {
|
||||
return;
|
||||
}
|
||||
|
||||
const references = undefinedVar.references;
|
||||
|
||||
const defs = undefinedVar.defs;
|
||||
|
||||
// Report non-initializing references (those are covered in defs below)
|
||||
references
|
||||
.filter(ref => !ref.init)
|
||||
.forEach(ref => report(ref.identifier));
|
||||
|
||||
defs.forEach(def => report(def.name));
|
||||
}
|
||||
|
||||
return {
|
||||
"Program:exit"(node) {
|
||||
const globalScope = sourceCode.getScope(node);
|
||||
|
||||
const stack = [globalScope];
|
||||
|
||||
while (stack.length) {
|
||||
const scope = stack.pop();
|
||||
|
||||
stack.push(...scope.childScopes);
|
||||
checkScope(scope);
|
||||
}
|
||||
},
|
||||
};
|
||||
},
|
||||
};
|
||||
@@ -0,0 +1,32 @@
|
||||
var test = require('tape');
|
||||
var stringify = require('../');
|
||||
|
||||
test('simple object', function (t) {
|
||||
t.plan(1);
|
||||
var obj = { c: 6, b: [4,5], a: 3, z: null };
|
||||
t.equal(stringify(obj), '{"a":3,"b":[4,5],"c":6,"z":null}');
|
||||
});
|
||||
|
||||
test('object with undefined', function (t) {
|
||||
t.plan(1);
|
||||
var obj = { a: 3, z: undefined };
|
||||
t.equal(stringify(obj), '{"a":3}');
|
||||
});
|
||||
|
||||
test('array with undefined', function (t) {
|
||||
t.plan(1);
|
||||
var obj = [4, undefined, 6];
|
||||
t.equal(stringify(obj), '[4,null,6]');
|
||||
});
|
||||
|
||||
test('object with empty string', function (t) {
|
||||
t.plan(1);
|
||||
var obj = { a: 3, z: '' };
|
||||
t.equal(stringify(obj), '{"a":3,"z":""}');
|
||||
});
|
||||
|
||||
test('array with empty string', function (t) {
|
||||
t.plan(1);
|
||||
var obj = [4, '', 6];
|
||||
t.equal(stringify(obj), '[4,"",6]');
|
||||
});
|
||||
@@ -0,0 +1,19 @@
|
||||
var test = require('tape');
|
||||
var github = require('../');
|
||||
var packages = {
|
||||
a : require('./a.json'),
|
||||
b : require('./b.json'),
|
||||
c : require('./c.json'),
|
||||
d : require('./d.json'),
|
||||
e : require('./e.json')
|
||||
};
|
||||
|
||||
test(function (t) {
|
||||
t.plan(5);
|
||||
var url = 'https://github.com/substack/beep-boop';
|
||||
t.equal(url, github(packages.a), 'a.json comparison');
|
||||
t.equal(url, github(packages.b), 'b.json comparison');
|
||||
t.equal(url, github(packages.c), 'c.json comparison');
|
||||
t.equal(url, github(packages.d), 'd.json comparison');
|
||||
t.equal(url, github(packages.e), 'e.json comparison');
|
||||
});
|
||||
@@ -0,0 +1,295 @@
|
||||
/**
|
||||
* @fileoverview Rule to disallow returning values from Promise executor functions
|
||||
* @author Milos Djermanovic
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Requirements
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
const { findVariable } = require("@eslint-community/eslint-utils");
|
||||
const astUtils = require("./utils/ast-utils");
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Helpers
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
const functionTypesToCheck = new Set([
|
||||
"ArrowFunctionExpression",
|
||||
"FunctionExpression",
|
||||
]);
|
||||
|
||||
/**
|
||||
* Determines whether the given identifier node is a reference to a global variable.
|
||||
* @param {ASTNode} node `Identifier` node to check.
|
||||
* @param {Scope} scope Scope to which the node belongs.
|
||||
* @returns {boolean} True if the identifier is a reference to a global variable.
|
||||
*/
|
||||
function isGlobalReference(node, scope) {
|
||||
const variable = findVariable(scope, node);
|
||||
|
||||
return (
|
||||
variable !== null &&
|
||||
variable.scope.type === "global" &&
|
||||
variable.defs.length === 0
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Finds function's outer scope.
|
||||
* @param {Scope} scope Function's own scope.
|
||||
* @returns {Scope} Function's outer scope.
|
||||
*/
|
||||
function getOuterScope(scope) {
|
||||
const upper = scope.upper;
|
||||
|
||||
if (upper.type === "function-expression-name") {
|
||||
return upper.upper;
|
||||
}
|
||||
return upper;
|
||||
}
|
||||
|
||||
/**
|
||||
* Determines whether the given function node is used as a Promise executor.
|
||||
* @param {ASTNode} node The node to check.
|
||||
* @param {Scope} scope Function's own scope.
|
||||
* @returns {boolean} `true` if the node is a Promise executor.
|
||||
*/
|
||||
function isPromiseExecutor(node, scope) {
|
||||
const parent = node.parent;
|
||||
|
||||
return (
|
||||
parent.type === "NewExpression" &&
|
||||
parent.arguments[0] === node &&
|
||||
parent.callee.type === "Identifier" &&
|
||||
parent.callee.name === "Promise" &&
|
||||
isGlobalReference(parent.callee, getOuterScope(scope))
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if the given node is a void expression.
|
||||
* @param {ASTNode} node The node to check.
|
||||
* @returns {boolean} - `true` if the node is a void expression
|
||||
*/
|
||||
function expressionIsVoid(node) {
|
||||
return node.type === "UnaryExpression" && node.operator === "void";
|
||||
}
|
||||
|
||||
/**
|
||||
* Fixes the linting error by prepending "void " to the given node
|
||||
* @param {Object} sourceCode context given by context.sourceCode
|
||||
* @param {ASTNode} node The node to fix.
|
||||
* @param {Object} fixer The fixer object provided by ESLint.
|
||||
* @returns {Array<Object>} - An array of fix objects to apply to the node.
|
||||
*/
|
||||
function voidPrependFixer(sourceCode, node, fixer) {
|
||||
const requiresParens =
|
||||
// prepending `void ` will fail if the node has a lower precedence than void
|
||||
astUtils.getPrecedence(node) <
|
||||
astUtils.getPrecedence({
|
||||
type: "UnaryExpression",
|
||||
operator: "void",
|
||||
}) &&
|
||||
// check if there are parentheses around the node to avoid redundant parentheses
|
||||
!astUtils.isParenthesised(sourceCode, node);
|
||||
|
||||
// avoid parentheses issues
|
||||
const returnOrArrowToken = sourceCode.getTokenBefore(
|
||||
node,
|
||||
node.parent.type === "ArrowFunctionExpression"
|
||||
? astUtils.isArrowToken
|
||||
: // isReturnToken
|
||||
token => token.type === "Keyword" && token.value === "return",
|
||||
);
|
||||
|
||||
const firstToken = sourceCode.getTokenAfter(returnOrArrowToken);
|
||||
|
||||
const prependSpace =
|
||||
// is return token, as => allows void to be adjacent
|
||||
returnOrArrowToken.value === "return" &&
|
||||
// If two tokens (return and "(") are adjacent
|
||||
returnOrArrowToken.range[1] === firstToken.range[0];
|
||||
|
||||
return [
|
||||
fixer.insertTextBefore(
|
||||
firstToken,
|
||||
`${prependSpace ? " " : ""}void ${requiresParens ? "(" : ""}`,
|
||||
),
|
||||
fixer.insertTextAfter(node, requiresParens ? ")" : ""),
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Fixes the linting error by `wrapping {}` around the given node's body.
|
||||
* @param {Object} sourceCode context given by context.sourceCode
|
||||
* @param {ASTNode} node The node to fix.
|
||||
* @param {Object} fixer The fixer object provided by ESLint.
|
||||
* @returns {Array<Object>} - An array of fix objects to apply to the node.
|
||||
*/
|
||||
function curlyWrapFixer(sourceCode, node, fixer) {
|
||||
// https://github.com/eslint/eslint/pull/17282#issuecomment-1592795923
|
||||
const arrowToken = sourceCode.getTokenBefore(
|
||||
node.body,
|
||||
astUtils.isArrowToken,
|
||||
);
|
||||
const firstToken = sourceCode.getTokenAfter(arrowToken);
|
||||
const lastToken = sourceCode.getLastToken(node);
|
||||
|
||||
return [
|
||||
fixer.insertTextBefore(firstToken, "{"),
|
||||
fixer.insertTextAfter(lastToken, "}"),
|
||||
];
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Rule Definition
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/** @type {import('../shared/types').Rule} */
|
||||
module.exports = {
|
||||
meta: {
|
||||
type: "problem",
|
||||
|
||||
defaultOptions: [
|
||||
{
|
||||
allowVoid: false,
|
||||
},
|
||||
],
|
||||
|
||||
docs: {
|
||||
description:
|
||||
"Disallow returning values from Promise executor functions",
|
||||
recommended: false,
|
||||
url: "https://eslint.org/docs/latest/rules/no-promise-executor-return",
|
||||
},
|
||||
|
||||
hasSuggestions: true,
|
||||
|
||||
schema: [
|
||||
{
|
||||
type: "object",
|
||||
properties: {
|
||||
allowVoid: {
|
||||
type: "boolean",
|
||||
},
|
||||
},
|
||||
additionalProperties: false,
|
||||
},
|
||||
],
|
||||
|
||||
messages: {
|
||||
returnsValue:
|
||||
"Return values from promise executor functions cannot be read.",
|
||||
|
||||
// arrow and function suggestions
|
||||
prependVoid: "Prepend `void` to the expression.",
|
||||
|
||||
// only arrow suggestions
|
||||
wrapBraces: "Wrap the expression in `{}`.",
|
||||
},
|
||||
},
|
||||
|
||||
create(context) {
|
||||
let funcInfo = null;
|
||||
const sourceCode = context.sourceCode;
|
||||
const [{ allowVoid }] = context.options;
|
||||
|
||||
return {
|
||||
onCodePathStart(_, node) {
|
||||
funcInfo = {
|
||||
upper: funcInfo,
|
||||
shouldCheck:
|
||||
functionTypesToCheck.has(node.type) &&
|
||||
isPromiseExecutor(node, sourceCode.getScope(node)),
|
||||
};
|
||||
|
||||
if (
|
||||
// Is a Promise executor
|
||||
funcInfo.shouldCheck &&
|
||||
node.type === "ArrowFunctionExpression" &&
|
||||
node.expression &&
|
||||
// Except void
|
||||
!(allowVoid && expressionIsVoid(node.body))
|
||||
) {
|
||||
const suggest = [];
|
||||
|
||||
// prevent useless refactors
|
||||
if (allowVoid) {
|
||||
suggest.push({
|
||||
messageId: "prependVoid",
|
||||
fix(fixer) {
|
||||
return voidPrependFixer(
|
||||
sourceCode,
|
||||
node.body,
|
||||
fixer,
|
||||
);
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
// Do not suggest wrapping an unnamed FunctionExpression in braces as that would be invalid syntax.
|
||||
if (
|
||||
!(
|
||||
node.body.type === "FunctionExpression" &&
|
||||
!node.body.id
|
||||
)
|
||||
) {
|
||||
suggest.push({
|
||||
messageId: "wrapBraces",
|
||||
fix(fixer) {
|
||||
return curlyWrapFixer(sourceCode, node, fixer);
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
context.report({
|
||||
node: node.body,
|
||||
messageId: "returnsValue",
|
||||
suggest,
|
||||
});
|
||||
}
|
||||
},
|
||||
|
||||
onCodePathEnd() {
|
||||
funcInfo = funcInfo.upper;
|
||||
},
|
||||
|
||||
ReturnStatement(node) {
|
||||
if (!(funcInfo.shouldCheck && node.argument)) {
|
||||
return;
|
||||
}
|
||||
|
||||
// node is `return <expression>`
|
||||
if (!allowVoid) {
|
||||
context.report({ node, messageId: "returnsValue" });
|
||||
return;
|
||||
}
|
||||
|
||||
if (expressionIsVoid(node.argument)) {
|
||||
return;
|
||||
}
|
||||
|
||||
// allowVoid && !expressionIsVoid
|
||||
context.report({
|
||||
node,
|
||||
messageId: "returnsValue",
|
||||
suggest: [
|
||||
{
|
||||
messageId: "prependVoid",
|
||||
fix(fixer) {
|
||||
return voidPrependFixer(
|
||||
sourceCode,
|
||||
node.argument,
|
||||
fixer,
|
||||
);
|
||||
},
|
||||
},
|
||||
],
|
||||
});
|
||||
},
|
||||
};
|
||||
},
|
||||
};
|
||||
@@ -0,0 +1,448 @@
|
||||
var fs = require('fs')
|
||||
var polyfills = require('./polyfills.js')
|
||||
var legacy = require('./legacy-streams.js')
|
||||
var clone = require('./clone.js')
|
||||
|
||||
var util = require('util')
|
||||
|
||||
/* istanbul ignore next - node 0.x polyfill */
|
||||
var gracefulQueue
|
||||
var previousSymbol
|
||||
|
||||
/* istanbul ignore else - node 0.x polyfill */
|
||||
if (typeof Symbol === 'function' && typeof Symbol.for === 'function') {
|
||||
gracefulQueue = Symbol.for('graceful-fs.queue')
|
||||
// This is used in testing by future versions
|
||||
previousSymbol = Symbol.for('graceful-fs.previous')
|
||||
} else {
|
||||
gracefulQueue = '___graceful-fs.queue'
|
||||
previousSymbol = '___graceful-fs.previous'
|
||||
}
|
||||
|
||||
function noop () {}
|
||||
|
||||
function publishQueue(context, queue) {
|
||||
Object.defineProperty(context, gracefulQueue, {
|
||||
get: function() {
|
||||
return queue
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
var debug = noop
|
||||
if (util.debuglog)
|
||||
debug = util.debuglog('gfs4')
|
||||
else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ''))
|
||||
debug = function() {
|
||||
var m = util.format.apply(util, arguments)
|
||||
m = 'GFS4: ' + m.split(/\n/).join('\nGFS4: ')
|
||||
console.error(m)
|
||||
}
|
||||
|
||||
// Once time initialization
|
||||
if (!fs[gracefulQueue]) {
|
||||
// This queue can be shared by multiple loaded instances
|
||||
var queue = global[gracefulQueue] || []
|
||||
publishQueue(fs, queue)
|
||||
|
||||
// Patch fs.close/closeSync to shared queue version, because we need
|
||||
// to retry() whenever a close happens *anywhere* in the program.
|
||||
// This is essential when multiple graceful-fs instances are
|
||||
// in play at the same time.
|
||||
fs.close = (function (fs$close) {
|
||||
function close (fd, cb) {
|
||||
return fs$close.call(fs, fd, function (err) {
|
||||
// This function uses the graceful-fs shared queue
|
||||
if (!err) {
|
||||
resetQueue()
|
||||
}
|
||||
|
||||
if (typeof cb === 'function')
|
||||
cb.apply(this, arguments)
|
||||
})
|
||||
}
|
||||
|
||||
Object.defineProperty(close, previousSymbol, {
|
||||
value: fs$close
|
||||
})
|
||||
return close
|
||||
})(fs.close)
|
||||
|
||||
fs.closeSync = (function (fs$closeSync) {
|
||||
function closeSync (fd) {
|
||||
// This function uses the graceful-fs shared queue
|
||||
fs$closeSync.apply(fs, arguments)
|
||||
resetQueue()
|
||||
}
|
||||
|
||||
Object.defineProperty(closeSync, previousSymbol, {
|
||||
value: fs$closeSync
|
||||
})
|
||||
return closeSync
|
||||
})(fs.closeSync)
|
||||
|
||||
if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) {
|
||||
process.on('exit', function() {
|
||||
debug(fs[gracefulQueue])
|
||||
require('assert').equal(fs[gracefulQueue].length, 0)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
if (!global[gracefulQueue]) {
|
||||
publishQueue(global, fs[gracefulQueue]);
|
||||
}
|
||||
|
||||
module.exports = patch(clone(fs))
|
||||
if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs.__patched) {
|
||||
module.exports = patch(fs)
|
||||
fs.__patched = true;
|
||||
}
|
||||
|
||||
function patch (fs) {
|
||||
// Everything that references the open() function needs to be in here
|
||||
polyfills(fs)
|
||||
fs.gracefulify = patch
|
||||
|
||||
fs.createReadStream = createReadStream
|
||||
fs.createWriteStream = createWriteStream
|
||||
var fs$readFile = fs.readFile
|
||||
fs.readFile = readFile
|
||||
function readFile (path, options, cb) {
|
||||
if (typeof options === 'function')
|
||||
cb = options, options = null
|
||||
|
||||
return go$readFile(path, options, cb)
|
||||
|
||||
function go$readFile (path, options, cb, startTime) {
|
||||
return fs$readFile(path, options, function (err) {
|
||||
if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
|
||||
enqueue([go$readFile, [path, options, cb], err, startTime || Date.now(), Date.now()])
|
||||
else {
|
||||
if (typeof cb === 'function')
|
||||
cb.apply(this, arguments)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
var fs$writeFile = fs.writeFile
|
||||
fs.writeFile = writeFile
|
||||
function writeFile (path, data, options, cb) {
|
||||
if (typeof options === 'function')
|
||||
cb = options, options = null
|
||||
|
||||
return go$writeFile(path, data, options, cb)
|
||||
|
||||
function go$writeFile (path, data, options, cb, startTime) {
|
||||
return fs$writeFile(path, data, options, function (err) {
|
||||
if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
|
||||
enqueue([go$writeFile, [path, data, options, cb], err, startTime || Date.now(), Date.now()])
|
||||
else {
|
||||
if (typeof cb === 'function')
|
||||
cb.apply(this, arguments)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
var fs$appendFile = fs.appendFile
|
||||
if (fs$appendFile)
|
||||
fs.appendFile = appendFile
|
||||
function appendFile (path, data, options, cb) {
|
||||
if (typeof options === 'function')
|
||||
cb = options, options = null
|
||||
|
||||
return go$appendFile(path, data, options, cb)
|
||||
|
||||
function go$appendFile (path, data, options, cb, startTime) {
|
||||
return fs$appendFile(path, data, options, function (err) {
|
||||
if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
|
||||
enqueue([go$appendFile, [path, data, options, cb], err, startTime || Date.now(), Date.now()])
|
||||
else {
|
||||
if (typeof cb === 'function')
|
||||
cb.apply(this, arguments)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
var fs$copyFile = fs.copyFile
|
||||
if (fs$copyFile)
|
||||
fs.copyFile = copyFile
|
||||
function copyFile (src, dest, flags, cb) {
|
||||
if (typeof flags === 'function') {
|
||||
cb = flags
|
||||
flags = 0
|
||||
}
|
||||
return go$copyFile(src, dest, flags, cb)
|
||||
|
||||
function go$copyFile (src, dest, flags, cb, startTime) {
|
||||
return fs$copyFile(src, dest, flags, function (err) {
|
||||
if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
|
||||
enqueue([go$copyFile, [src, dest, flags, cb], err, startTime || Date.now(), Date.now()])
|
||||
else {
|
||||
if (typeof cb === 'function')
|
||||
cb.apply(this, arguments)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
var fs$readdir = fs.readdir
|
||||
fs.readdir = readdir
|
||||
var noReaddirOptionVersions = /^v[0-5]\./
|
||||
function readdir (path, options, cb) {
|
||||
if (typeof options === 'function')
|
||||
cb = options, options = null
|
||||
|
||||
var go$readdir = noReaddirOptionVersions.test(process.version)
|
||||
? function go$readdir (path, options, cb, startTime) {
|
||||
return fs$readdir(path, fs$readdirCallback(
|
||||
path, options, cb, startTime
|
||||
))
|
||||
}
|
||||
: function go$readdir (path, options, cb, startTime) {
|
||||
return fs$readdir(path, options, fs$readdirCallback(
|
||||
path, options, cb, startTime
|
||||
))
|
||||
}
|
||||
|
||||
return go$readdir(path, options, cb)
|
||||
|
||||
function fs$readdirCallback (path, options, cb, startTime) {
|
||||
return function (err, files) {
|
||||
if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
|
||||
enqueue([
|
||||
go$readdir,
|
||||
[path, options, cb],
|
||||
err,
|
||||
startTime || Date.now(),
|
||||
Date.now()
|
||||
])
|
||||
else {
|
||||
if (files && files.sort)
|
||||
files.sort()
|
||||
|
||||
if (typeof cb === 'function')
|
||||
cb.call(this, err, files)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (process.version.substr(0, 4) === 'v0.8') {
|
||||
var legStreams = legacy(fs)
|
||||
ReadStream = legStreams.ReadStream
|
||||
WriteStream = legStreams.WriteStream
|
||||
}
|
||||
|
||||
var fs$ReadStream = fs.ReadStream
|
||||
if (fs$ReadStream) {
|
||||
ReadStream.prototype = Object.create(fs$ReadStream.prototype)
|
||||
ReadStream.prototype.open = ReadStream$open
|
||||
}
|
||||
|
||||
var fs$WriteStream = fs.WriteStream
|
||||
if (fs$WriteStream) {
|
||||
WriteStream.prototype = Object.create(fs$WriteStream.prototype)
|
||||
WriteStream.prototype.open = WriteStream$open
|
||||
}
|
||||
|
||||
Object.defineProperty(fs, 'ReadStream', {
|
||||
get: function () {
|
||||
return ReadStream
|
||||
},
|
||||
set: function (val) {
|
||||
ReadStream = val
|
||||
},
|
||||
enumerable: true,
|
||||
configurable: true
|
||||
})
|
||||
Object.defineProperty(fs, 'WriteStream', {
|
||||
get: function () {
|
||||
return WriteStream
|
||||
},
|
||||
set: function (val) {
|
||||
WriteStream = val
|
||||
},
|
||||
enumerable: true,
|
||||
configurable: true
|
||||
})
|
||||
|
||||
// legacy names
|
||||
var FileReadStream = ReadStream
|
||||
Object.defineProperty(fs, 'FileReadStream', {
|
||||
get: function () {
|
||||
return FileReadStream
|
||||
},
|
||||
set: function (val) {
|
||||
FileReadStream = val
|
||||
},
|
||||
enumerable: true,
|
||||
configurable: true
|
||||
})
|
||||
var FileWriteStream = WriteStream
|
||||
Object.defineProperty(fs, 'FileWriteStream', {
|
||||
get: function () {
|
||||
return FileWriteStream
|
||||
},
|
||||
set: function (val) {
|
||||
FileWriteStream = val
|
||||
},
|
||||
enumerable: true,
|
||||
configurable: true
|
||||
})
|
||||
|
||||
function ReadStream (path, options) {
|
||||
if (this instanceof ReadStream)
|
||||
return fs$ReadStream.apply(this, arguments), this
|
||||
else
|
||||
return ReadStream.apply(Object.create(ReadStream.prototype), arguments)
|
||||
}
|
||||
|
||||
function ReadStream$open () {
|
||||
var that = this
|
||||
open(that.path, that.flags, that.mode, function (err, fd) {
|
||||
if (err) {
|
||||
if (that.autoClose)
|
||||
that.destroy()
|
||||
|
||||
that.emit('error', err)
|
||||
} else {
|
||||
that.fd = fd
|
||||
that.emit('open', fd)
|
||||
that.read()
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
function WriteStream (path, options) {
|
||||
if (this instanceof WriteStream)
|
||||
return fs$WriteStream.apply(this, arguments), this
|
||||
else
|
||||
return WriteStream.apply(Object.create(WriteStream.prototype), arguments)
|
||||
}
|
||||
|
||||
function WriteStream$open () {
|
||||
var that = this
|
||||
open(that.path, that.flags, that.mode, function (err, fd) {
|
||||
if (err) {
|
||||
that.destroy()
|
||||
that.emit('error', err)
|
||||
} else {
|
||||
that.fd = fd
|
||||
that.emit('open', fd)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
function createReadStream (path, options) {
|
||||
return new fs.ReadStream(path, options)
|
||||
}
|
||||
|
||||
function createWriteStream (path, options) {
|
||||
return new fs.WriteStream(path, options)
|
||||
}
|
||||
|
||||
var fs$open = fs.open
|
||||
fs.open = open
|
||||
function open (path, flags, mode, cb) {
|
||||
if (typeof mode === 'function')
|
||||
cb = mode, mode = null
|
||||
|
||||
return go$open(path, flags, mode, cb)
|
||||
|
||||
function go$open (path, flags, mode, cb, startTime) {
|
||||
return fs$open(path, flags, mode, function (err, fd) {
|
||||
if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
|
||||
enqueue([go$open, [path, flags, mode, cb], err, startTime || Date.now(), Date.now()])
|
||||
else {
|
||||
if (typeof cb === 'function')
|
||||
cb.apply(this, arguments)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
return fs
|
||||
}
|
||||
|
||||
function enqueue (elem) {
|
||||
debug('ENQUEUE', elem[0].name, elem[1])
|
||||
fs[gracefulQueue].push(elem)
|
||||
retry()
|
||||
}
|
||||
|
||||
// keep track of the timeout between retry() calls
|
||||
var retryTimer
|
||||
|
||||
// reset the startTime and lastTime to now
|
||||
// this resets the start of the 60 second overall timeout as well as the
|
||||
// delay between attempts so that we'll retry these jobs sooner
|
||||
function resetQueue () {
|
||||
var now = Date.now()
|
||||
for (var i = 0; i < fs[gracefulQueue].length; ++i) {
|
||||
// entries that are only a length of 2 are from an older version, don't
|
||||
// bother modifying those since they'll be retried anyway.
|
||||
if (fs[gracefulQueue][i].length > 2) {
|
||||
fs[gracefulQueue][i][3] = now // startTime
|
||||
fs[gracefulQueue][i][4] = now // lastTime
|
||||
}
|
||||
}
|
||||
// call retry to make sure we're actively processing the queue
|
||||
retry()
|
||||
}
|
||||
|
||||
function retry () {
|
||||
// clear the timer and remove it to help prevent unintended concurrency
|
||||
clearTimeout(retryTimer)
|
||||
retryTimer = undefined
|
||||
|
||||
if (fs[gracefulQueue].length === 0)
|
||||
return
|
||||
|
||||
var elem = fs[gracefulQueue].shift()
|
||||
var fn = elem[0]
|
||||
var args = elem[1]
|
||||
// these items may be unset if they were added by an older graceful-fs
|
||||
var err = elem[2]
|
||||
var startTime = elem[3]
|
||||
var lastTime = elem[4]
|
||||
|
||||
// if we don't have a startTime we have no way of knowing if we've waited
|
||||
// long enough, so go ahead and retry this item now
|
||||
if (startTime === undefined) {
|
||||
debug('RETRY', fn.name, args)
|
||||
fn.apply(null, args)
|
||||
} else if (Date.now() - startTime >= 60000) {
|
||||
// it's been more than 60 seconds total, bail now
|
||||
debug('TIMEOUT', fn.name, args)
|
||||
var cb = args.pop()
|
||||
if (typeof cb === 'function')
|
||||
cb.call(null, err)
|
||||
} else {
|
||||
// the amount of time between the last attempt and right now
|
||||
var sinceAttempt = Date.now() - lastTime
|
||||
// the amount of time between when we first tried, and when we last tried
|
||||
// rounded up to at least 1
|
||||
var sinceStart = Math.max(lastTime - startTime, 1)
|
||||
// backoff. wait longer than the total time we've been retrying, but only
|
||||
// up to a maximum of 100ms
|
||||
var desiredDelay = Math.min(sinceStart * 1.2, 100)
|
||||
// it's been long enough since the last retry, do it again
|
||||
if (sinceAttempt >= desiredDelay) {
|
||||
debug('RETRY', fn.name, args)
|
||||
fn.apply(null, args.concat([startTime]))
|
||||
} else {
|
||||
// if we can't do this job yet, push it to the end of the queue
|
||||
// and let the next iteration check again
|
||||
fs[gracefulQueue].push(elem)
|
||||
}
|
||||
}
|
||||
|
||||
// schedule our next run if one isn't already scheduled
|
||||
if (retryTimer === undefined) {
|
||||
retryTimer = setTimeout(retry, 0)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"names":[],"sources":["../src/types.ts"],"sourcesContent":["import type * as t from \"@babel/types\";\nimport type { NodePath } from \"./index.ts\";\nimport type { VirtualTypeAliases } from \"./path/lib/virtual-types.ts\";\nimport type {\n ExplVisitorBase,\n VisitorBaseNodes,\n VisitorBaseAliases,\n} from \"./generated/visitor-types.d.ts\";\n\nexport type VisitPhase = \"enter\" | \"exit\";\n\ninterface VisitNodeObject<S, P extends t.Node> {\n enter?: VisitNodeFunction<S, P>;\n exit?: VisitNodeFunction<S, P>;\n}\n\nexport interface ExplVisitNode<S, P extends t.Node> {\n enter?: VisitNodeFunction<S, P>[];\n exit?: VisitNodeFunction<S, P>[];\n}\n\nexport interface ExplodedVisitor<S = unknown>\n extends ExplVisitorBase<S>,\n ExplVisitNode<S, t.Node> {\n _exploded: true;\n _verified: true;\n}\n\n// TODO: Assert that the keys of this are the keys of VirtualTypeAliases without\n// the keys of VisitorBaseNodes and VisitorBaseAliases\n// prettier-ignore\ninterface VisitorVirtualAliases<S> {\n BindingIdentifier?: VisitNode<S, VirtualTypeAliases[\"BindingIdentifier\"]>;\n BlockScoped?: VisitNode<S, VirtualTypeAliases[\"BlockScoped\"]>;\n ExistentialTypeParam?: VisitNode<S, VirtualTypeAliases[\"ExistentialTypeParam\"]>;\n Expression?: VisitNode<S, VirtualTypeAliases[\"Expression\"]>;\n //Flow?: VisitNode<S, VirtualTypeAliases[\"Flow\"]>;\n ForAwaitStatement?: VisitNode<S, VirtualTypeAliases[\"ForAwaitStatement\"]>;\n Generated?: VisitNode<S, VirtualTypeAliases[\"Generated\"]>;\n NumericLiteralTypeAnnotation?: VisitNode<S, VirtualTypeAliases[\"NumericLiteralTypeAnnotation\"]>;\n Pure?: VisitNode<S, VirtualTypeAliases[\"Pure\"]>;\n Referenced?: VisitNode<S, VirtualTypeAliases[\"Referenced\"]>;\n ReferencedIdentifier?: VisitNode<S, VirtualTypeAliases[\"ReferencedIdentifier\"]>;\n ReferencedMemberExpression?: VisitNode<S, VirtualTypeAliases[\"ReferencedMemberExpression\"]>;\n //RestProperty?: VisitNode<S, VirtualTypeAliases[\"RestProperty\"]>;\n Scope?: VisitNode<S, VirtualTypeAliases[\"Scope\"]>;\n //SpreadProperty?: VisitNode<S, VirtualTypeAliases[\"SpreadProperty\"]>;\n Statement?: VisitNode<S, VirtualTypeAliases[\"Statement\"]>;\n User?: VisitNode<S, VirtualTypeAliases[\"User\"]>;\n Var?: VisitNode<S, VirtualTypeAliases[\"Var\"]>;\n}\n\n// TODO: Do not export this? Or give it a better name?\nexport interface VisitorBase<S>\n extends VisitNodeObject<S, t.Node>,\n VisitorBaseNodes<S>,\n VisitorBaseAliases<S>,\n VisitorVirtualAliases<S> {\n // Babel supports `NodeTypesWithoutComment | NodeTypesWithoutComment | ... ` but it is\n // too complex for TS. So we type it as a general visitor only if the key contains `|`\n // this is good enough for non-visitor traverse options e.g. `noScope`\n [k: `${string}|${string}`]: VisitNode<S, t.Node>;\n}\n\nexport type Visitor<S = unknown> = VisitorBase<S> | ExplodedVisitor<S>;\n\nexport type VisitNode<S, P extends t.Node> =\n | VisitNodeFunction<S, P>\n | VisitNodeObject<S, P>;\n\nexport type VisitNodeFunction<S, P extends t.Node> = (\n this: S,\n path: NodePath<P>,\n state: S,\n) => void;\n"],"mappings":"","ignoreList":[]}
|
||||
@@ -0,0 +1 @@
|
||||
module.exports={A:{A:{"2":"K D E mC","260":"F","516":"A B"},B:{"1":"0 9 C L M G N O P Q H R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB I"},C:{"1":"0 1 2 3 4 5 6 7 8 9 N O P QB RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB MC wB NC xB yB zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC Q H R OC S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB I PC EC QC RC oC pC","2":"nC LC qC rC","33":"J PB K D E F A B C L M G"},D:{"1":"0 7 8 9 RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB MC wB NC xB yB zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC Q H R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB I PC EC QC RC","2":"J PB K D E F A B C L M G N O P","33":"1 2 3 4 5 6 QB"},E:{"1":"D E F A B C L M G uC vC wC TC FC GC xC yC zC UC VC HC 0C IC WC XC YC ZC aC 1C JC bC cC dC eC fC 2C KC gC hC iC jC 3C","2":"J PB sC SC tC","33":"K"},F:{"1":"0 1 2 3 4 5 6 7 8 G N O P QB RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB wB xB yB zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC Q H R OC S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z","2":"F B C 4C 5C 6C 7C FC kC 8C GC"},G:{"1":"E CD DD ED FD GD HD ID JD KD LD MD ND OD PD QD RD SD UC VC HC TD IC WC XC YC ZC aC UD JC bC cC dC eC fC VD KC gC hC iC jC","2":"SC 9C lC AD","33":"BD"},H:{"2":"WD"},I:{"1":"I","2":"LC J XD YD ZD aD lC","132":"bD cD"},J:{"1":"A","2":"D"},K:{"1":"H","2":"A B C FC kC GC"},L:{"1":"I"},M:{"1":"EC"},N:{"1":"A B"},O:{"1":"HC"},P:{"1":"1 2 3 4 5 6 7 8 J dD eD fD gD hD TC iD jD kD lD mD IC JC KC nD"},Q:{"1":"oD"},R:{"1":"pD"},S:{"1":"qD rD"}},B:4,C:"calc() as CSS unit value",D:true};
|
||||
@@ -0,0 +1,167 @@
|
||||
'use strict'
|
||||
const fs = require('fs')
|
||||
const path = require('path')
|
||||
|
||||
/* istanbul ignore next */
|
||||
const LCHOWN = fs.lchown ? 'lchown' : 'chown'
|
||||
/* istanbul ignore next */
|
||||
const LCHOWNSYNC = fs.lchownSync ? 'lchownSync' : 'chownSync'
|
||||
|
||||
/* istanbul ignore next */
|
||||
const needEISDIRHandled = fs.lchown &&
|
||||
!process.version.match(/v1[1-9]+\./) &&
|
||||
!process.version.match(/v10\.[6-9]/)
|
||||
|
||||
const lchownSync = (path, uid, gid) => {
|
||||
try {
|
||||
return fs[LCHOWNSYNC](path, uid, gid)
|
||||
} catch (er) {
|
||||
if (er.code !== 'ENOENT')
|
||||
throw er
|
||||
}
|
||||
}
|
||||
|
||||
/* istanbul ignore next */
|
||||
const chownSync = (path, uid, gid) => {
|
||||
try {
|
||||
return fs.chownSync(path, uid, gid)
|
||||
} catch (er) {
|
||||
if (er.code !== 'ENOENT')
|
||||
throw er
|
||||
}
|
||||
}
|
||||
|
||||
/* istanbul ignore next */
|
||||
const handleEISDIR =
|
||||
needEISDIRHandled ? (path, uid, gid, cb) => er => {
|
||||
// Node prior to v10 had a very questionable implementation of
|
||||
// fs.lchown, which would always try to call fs.open on a directory
|
||||
// Fall back to fs.chown in those cases.
|
||||
if (!er || er.code !== 'EISDIR')
|
||||
cb(er)
|
||||
else
|
||||
fs.chown(path, uid, gid, cb)
|
||||
}
|
||||
: (_, __, ___, cb) => cb
|
||||
|
||||
/* istanbul ignore next */
|
||||
const handleEISDirSync =
|
||||
needEISDIRHandled ? (path, uid, gid) => {
|
||||
try {
|
||||
return lchownSync(path, uid, gid)
|
||||
} catch (er) {
|
||||
if (er.code !== 'EISDIR')
|
||||
throw er
|
||||
chownSync(path, uid, gid)
|
||||
}
|
||||
}
|
||||
: (path, uid, gid) => lchownSync(path, uid, gid)
|
||||
|
||||
// fs.readdir could only accept an options object as of node v6
|
||||
const nodeVersion = process.version
|
||||
let readdir = (path, options, cb) => fs.readdir(path, options, cb)
|
||||
let readdirSync = (path, options) => fs.readdirSync(path, options)
|
||||
/* istanbul ignore next */
|
||||
if (/^v4\./.test(nodeVersion))
|
||||
readdir = (path, options, cb) => fs.readdir(path, cb)
|
||||
|
||||
const chown = (cpath, uid, gid, cb) => {
|
||||
fs[LCHOWN](cpath, uid, gid, handleEISDIR(cpath, uid, gid, er => {
|
||||
// Skip ENOENT error
|
||||
cb(er && er.code !== 'ENOENT' ? er : null)
|
||||
}))
|
||||
}
|
||||
|
||||
const chownrKid = (p, child, uid, gid, cb) => {
|
||||
if (typeof child === 'string')
|
||||
return fs.lstat(path.resolve(p, child), (er, stats) => {
|
||||
// Skip ENOENT error
|
||||
if (er)
|
||||
return cb(er.code !== 'ENOENT' ? er : null)
|
||||
stats.name = child
|
||||
chownrKid(p, stats, uid, gid, cb)
|
||||
})
|
||||
|
||||
if (child.isDirectory()) {
|
||||
chownr(path.resolve(p, child.name), uid, gid, er => {
|
||||
if (er)
|
||||
return cb(er)
|
||||
const cpath = path.resolve(p, child.name)
|
||||
chown(cpath, uid, gid, cb)
|
||||
})
|
||||
} else {
|
||||
const cpath = path.resolve(p, child.name)
|
||||
chown(cpath, uid, gid, cb)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
const chownr = (p, uid, gid, cb) => {
|
||||
readdir(p, { withFileTypes: true }, (er, children) => {
|
||||
// any error other than ENOTDIR or ENOTSUP means it's not readable,
|
||||
// or doesn't exist. give up.
|
||||
if (er) {
|
||||
if (er.code === 'ENOENT')
|
||||
return cb()
|
||||
else if (er.code !== 'ENOTDIR' && er.code !== 'ENOTSUP')
|
||||
return cb(er)
|
||||
}
|
||||
if (er || !children.length)
|
||||
return chown(p, uid, gid, cb)
|
||||
|
||||
let len = children.length
|
||||
let errState = null
|
||||
const then = er => {
|
||||
if (errState)
|
||||
return
|
||||
if (er)
|
||||
return cb(errState = er)
|
||||
if (-- len === 0)
|
||||
return chown(p, uid, gid, cb)
|
||||
}
|
||||
|
||||
children.forEach(child => chownrKid(p, child, uid, gid, then))
|
||||
})
|
||||
}
|
||||
|
||||
const chownrKidSync = (p, child, uid, gid) => {
|
||||
if (typeof child === 'string') {
|
||||
try {
|
||||
const stats = fs.lstatSync(path.resolve(p, child))
|
||||
stats.name = child
|
||||
child = stats
|
||||
} catch (er) {
|
||||
if (er.code === 'ENOENT')
|
||||
return
|
||||
else
|
||||
throw er
|
||||
}
|
||||
}
|
||||
|
||||
if (child.isDirectory())
|
||||
chownrSync(path.resolve(p, child.name), uid, gid)
|
||||
|
||||
handleEISDirSync(path.resolve(p, child.name), uid, gid)
|
||||
}
|
||||
|
||||
const chownrSync = (p, uid, gid) => {
|
||||
let children
|
||||
try {
|
||||
children = readdirSync(p, { withFileTypes: true })
|
||||
} catch (er) {
|
||||
if (er.code === 'ENOENT')
|
||||
return
|
||||
else if (er.code === 'ENOTDIR' || er.code === 'ENOTSUP')
|
||||
return handleEISDirSync(p, uid, gid)
|
||||
else
|
||||
throw er
|
||||
}
|
||||
|
||||
if (children && children.length)
|
||||
children.forEach(child => chownrKidSync(p, child, uid, gid))
|
||||
|
||||
return handleEISDirSync(p, uid, gid)
|
||||
}
|
||||
|
||||
module.exports = chownr
|
||||
chownr.sync = chownrSync
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"names":["_isValidIdentifier","require","RESERVED_WORDS_ES3_ONLY","Set","isValidES3Identifier","name","isValidIdentifier","has"],"sources":["../../src/validators/isValidES3Identifier.ts"],"sourcesContent":["import isValidIdentifier from \"./isValidIdentifier.ts\";\n\nconst RESERVED_WORDS_ES3_ONLY: Set<string> = new Set([\n \"abstract\",\n \"boolean\",\n \"byte\",\n \"char\",\n \"double\",\n \"enum\",\n \"final\",\n \"float\",\n \"goto\",\n \"implements\",\n \"int\",\n \"interface\",\n \"long\",\n \"native\",\n \"package\",\n \"private\",\n \"protected\",\n \"public\",\n \"short\",\n \"static\",\n \"synchronized\",\n \"throws\",\n \"transient\",\n \"volatile\",\n]);\n\n/**\n * Check if the input `name` is a valid identifier name according to the ES3 specification.\n *\n * Additional ES3 reserved words are\n */\nexport default function isValidES3Identifier(name: string): boolean {\n return isValidIdentifier(name) && !RESERVED_WORDS_ES3_ONLY.has(name);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,kBAAA,GAAAC,OAAA;AAEA,MAAMC,uBAAoC,GAAG,IAAIC,GAAG,CAAC,CACnD,UAAU,EACV,SAAS,EACT,MAAM,EACN,MAAM,EACN,QAAQ,EACR,MAAM,EACN,OAAO,EACP,OAAO,EACP,MAAM,EACN,YAAY,EACZ,KAAK,EACL,WAAW,EACX,MAAM,EACN,QAAQ,EACR,SAAS,EACT,SAAS,EACT,WAAW,EACX,QAAQ,EACR,OAAO,EACP,QAAQ,EACR,cAAc,EACd,QAAQ,EACR,WAAW,EACX,UAAU,CACX,CAAC;AAOa,SAASC,oBAAoBA,CAACC,IAAY,EAAW;EAClE,OAAO,IAAAC,0BAAiB,EAACD,IAAI,CAAC,IAAI,CAACH,uBAAuB,CAACK,GAAG,CAACF,IAAI,CAAC;AACtE","ignoreList":[]}
|
||||
@@ -0,0 +1,6 @@
|
||||
"use strict";
|
||||
'use client';
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const react_1 = require("react");
|
||||
const pageContext = (0, react_1.createContext)(null);
|
||||
exports.default = pageContext;
|
||||
@@ -0,0 +1,175 @@
|
||||
/*
|
||||
MIT License http://www.opensource.org/licenses/mit-license.php
|
||||
Author Tobias Koppers @sokra
|
||||
*/
|
||||
"use strict";
|
||||
|
||||
const util = require("util");
|
||||
|
||||
const deprecateContext = util.deprecate(() => {},
|
||||
"Hook.context is deprecated and will be removed");
|
||||
|
||||
const CALL_DELEGATE = function(...args) {
|
||||
this.call = this._createCall("sync");
|
||||
return this.call(...args);
|
||||
};
|
||||
const CALL_ASYNC_DELEGATE = function(...args) {
|
||||
this.callAsync = this._createCall("async");
|
||||
return this.callAsync(...args);
|
||||
};
|
||||
const PROMISE_DELEGATE = function(...args) {
|
||||
this.promise = this._createCall("promise");
|
||||
return this.promise(...args);
|
||||
};
|
||||
|
||||
class Hook {
|
||||
constructor(args = [], name = undefined) {
|
||||
this._args = args;
|
||||
this.name = name;
|
||||
this.taps = [];
|
||||
this.interceptors = [];
|
||||
this._call = CALL_DELEGATE;
|
||||
this.call = CALL_DELEGATE;
|
||||
this._callAsync = CALL_ASYNC_DELEGATE;
|
||||
this.callAsync = CALL_ASYNC_DELEGATE;
|
||||
this._promise = PROMISE_DELEGATE;
|
||||
this.promise = PROMISE_DELEGATE;
|
||||
this._x = undefined;
|
||||
|
||||
this.compile = this.compile;
|
||||
this.tap = this.tap;
|
||||
this.tapAsync = this.tapAsync;
|
||||
this.tapPromise = this.tapPromise;
|
||||
}
|
||||
|
||||
compile(options) {
|
||||
throw new Error("Abstract: should be overridden");
|
||||
}
|
||||
|
||||
_createCall(type) {
|
||||
return this.compile({
|
||||
taps: this.taps,
|
||||
interceptors: this.interceptors,
|
||||
args: this._args,
|
||||
type: type
|
||||
});
|
||||
}
|
||||
|
||||
_tap(type, options, fn) {
|
||||
if (typeof options === "string") {
|
||||
options = {
|
||||
name: options.trim()
|
||||
};
|
||||
} else if (typeof options !== "object" || options === null) {
|
||||
throw new Error("Invalid tap options");
|
||||
}
|
||||
if (typeof options.name !== "string" || options.name === "") {
|
||||
throw new Error("Missing name for tap");
|
||||
}
|
||||
if (typeof options.context !== "undefined") {
|
||||
deprecateContext();
|
||||
}
|
||||
options = Object.assign({ type, fn }, options);
|
||||
options = this._runRegisterInterceptors(options);
|
||||
this._insert(options);
|
||||
}
|
||||
|
||||
tap(options, fn) {
|
||||
this._tap("sync", options, fn);
|
||||
}
|
||||
|
||||
tapAsync(options, fn) {
|
||||
this._tap("async", options, fn);
|
||||
}
|
||||
|
||||
tapPromise(options, fn) {
|
||||
this._tap("promise", options, fn);
|
||||
}
|
||||
|
||||
_runRegisterInterceptors(options) {
|
||||
for (const interceptor of this.interceptors) {
|
||||
if (interceptor.register) {
|
||||
const newOptions = interceptor.register(options);
|
||||
if (newOptions !== undefined) {
|
||||
options = newOptions;
|
||||
}
|
||||
}
|
||||
}
|
||||
return options;
|
||||
}
|
||||
|
||||
withOptions(options) {
|
||||
const mergeOptions = opt =>
|
||||
Object.assign({}, options, typeof opt === "string" ? { name: opt } : opt);
|
||||
|
||||
return {
|
||||
name: this.name,
|
||||
tap: (opt, fn) => this.tap(mergeOptions(opt), fn),
|
||||
tapAsync: (opt, fn) => this.tapAsync(mergeOptions(opt), fn),
|
||||
tapPromise: (opt, fn) => this.tapPromise(mergeOptions(opt), fn),
|
||||
intercept: interceptor => this.intercept(interceptor),
|
||||
isUsed: () => this.isUsed(),
|
||||
withOptions: opt => this.withOptions(mergeOptions(opt))
|
||||
};
|
||||
}
|
||||
|
||||
isUsed() {
|
||||
return this.taps.length > 0 || this.interceptors.length > 0;
|
||||
}
|
||||
|
||||
intercept(interceptor) {
|
||||
this._resetCompilation();
|
||||
this.interceptors.push(Object.assign({}, interceptor));
|
||||
if (interceptor.register) {
|
||||
for (let i = 0; i < this.taps.length; i++) {
|
||||
this.taps[i] = interceptor.register(this.taps[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
_resetCompilation() {
|
||||
this.call = this._call;
|
||||
this.callAsync = this._callAsync;
|
||||
this.promise = this._promise;
|
||||
}
|
||||
|
||||
_insert(item) {
|
||||
this._resetCompilation();
|
||||
let before;
|
||||
if (typeof item.before === "string") {
|
||||
before = new Set([item.before]);
|
||||
} else if (Array.isArray(item.before)) {
|
||||
before = new Set(item.before);
|
||||
}
|
||||
let stage = 0;
|
||||
if (typeof item.stage === "number") {
|
||||
stage = item.stage;
|
||||
}
|
||||
let i = this.taps.length;
|
||||
while (i > 0) {
|
||||
i--;
|
||||
const x = this.taps[i];
|
||||
this.taps[i + 1] = x;
|
||||
const xStage = x.stage || 0;
|
||||
if (before) {
|
||||
if (before.has(x.name)) {
|
||||
before.delete(x.name);
|
||||
continue;
|
||||
}
|
||||
if (before.size > 0) {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
if (xStage > stage) {
|
||||
continue;
|
||||
}
|
||||
i++;
|
||||
break;
|
||||
}
|
||||
this.taps[i] = item;
|
||||
}
|
||||
}
|
||||
|
||||
Object.setPrototypeOf(Hook.prototype, null);
|
||||
|
||||
module.exports = Hook;
|
||||
@@ -0,0 +1,53 @@
|
||||
'use strict';
|
||||
|
||||
var Type = require('../type');
|
||||
|
||||
var _toString = Object.prototype.toString;
|
||||
|
||||
function resolveYamlPairs(data) {
|
||||
if (data === null) return true;
|
||||
|
||||
var index, length, pair, keys, result,
|
||||
object = data;
|
||||
|
||||
result = new Array(object.length);
|
||||
|
||||
for (index = 0, length = object.length; index < length; index += 1) {
|
||||
pair = object[index];
|
||||
|
||||
if (_toString.call(pair) !== '[object Object]') return false;
|
||||
|
||||
keys = Object.keys(pair);
|
||||
|
||||
if (keys.length !== 1) return false;
|
||||
|
||||
result[index] = [ keys[0], pair[keys[0]] ];
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
function constructYamlPairs(data) {
|
||||
if (data === null) return [];
|
||||
|
||||
var index, length, pair, keys, result,
|
||||
object = data;
|
||||
|
||||
result = new Array(object.length);
|
||||
|
||||
for (index = 0, length = object.length; index < length; index += 1) {
|
||||
pair = object[index];
|
||||
|
||||
keys = Object.keys(pair);
|
||||
|
||||
result[index] = [ keys[0], pair[keys[0]] ];
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
module.exports = new Type('tag:yaml.org,2002:pairs', {
|
||||
kind: 'sequence',
|
||||
resolve: resolveYamlPairs,
|
||||
construct: constructYamlPairs
|
||||
});
|
||||
Reference in New Issue
Block a user