vaderjs 1.1.3 → 1.1.4

package/website/node_modules/sucrase/dist/esm/transformers/JestHoistTransformer.js

@@ -1,111 +0,0 @@
- function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
-
-import {TokenType as tt} from "../parser/tokenizer/types";
-
-
-import Transformer from "./Transformer";
-
-const JEST_GLOBAL_NAME = "jest";
-const HOISTED_METHODS = ["mock", "unmock", "enableAutomock", "disableAutomock"];
-
-/**
- * Implementation of babel-plugin-jest-hoist, which hoists up some jest method
- * calls above the imports to allow them to override other imports.
- *
- * To preserve line numbers, rather than directly moving the jest.mock code, we
- * wrap each invocation in a function statement and then call the function from
- * the top of the file.
- */
-export default class JestHoistTransformer extends Transformer {
-    __init() {this.hoistedFunctionNames = []}
-
-  constructor(
-     rootTransformer,
-     tokens,
-     nameManager,
-     importProcessor,
-  ) {
-    super();this.rootTransformer = rootTransformer;this.tokens = tokens;this.nameManager = nameManager;this.importProcessor = importProcessor;JestHoistTransformer.prototype.__init.call(this);;
-  }
-
-  process() {
-    if (
-      this.tokens.currentToken().scopeDepth === 0 &&
-      this.tokens.matches4(tt.name, tt.dot, tt.name, tt.parenL) &&
-      this.tokens.identifierName() === JEST_GLOBAL_NAME
-    ) {
-      // TODO: This only works if imports transform is active, which it will be for jest.
-      //       But if jest adds module support and we no longer need the import transform, this needs fixing.
-      if (_optionalChain([this, 'access', _ => _.importProcessor, 'optionalAccess', _2 => _2.getGlobalNames, 'call', _3 => _3(), 'optionalAccess', _4 => _4.has, 'call', _5 => _5(JEST_GLOBAL_NAME)])) {
-        return false;
-      }
-      return this.extractHoistedCalls();
-    }
-
-    return false;
-  }
-
-  getHoistedCode() {
-    if (this.hoistedFunctionNames.length > 0) {
-      // This will be placed before module interop code, but that's fine since
-      // imports aren't allowed in module mock factories.
-      return this.hoistedFunctionNames.map((name) => `${name}();`).join("");
-    }
-    return "";
-  }
-
-  /**
-   * Extracts any methods calls on the jest-object that should be hoisted.
-   *
-   * According to the jest docs, https://jestjs.io/docs/en/jest-object#jestmockmodulename-factory-options,
-   * mock, unmock, enableAutomock, disableAutomock, are the methods that should be hoisted.
-   *
-   * We do not apply the same checks of the arguments as babel-plugin-jest-hoist does.
-   */
-   extractHoistedCalls() {
-    // We're handling a chain of calls where `jest` may or may not need to be inserted for each call
-    // in the chain, so remove the initial `jest` to make the loop implementation cleaner.
-    this.tokens.removeToken();
-    // Track some state so that multiple non-hoisted chained calls in a row keep their chaining
-    // syntax.
-    let followsNonHoistedJestCall = false;
-
-    // Iterate through all chained calls on the jest object.
-    while (this.tokens.matches3(tt.dot, tt.name, tt.parenL)) {
-      const methodName = this.tokens.identifierNameAtIndex(this.tokens.currentIndex() + 1);
-      const shouldHoist = HOISTED_METHODS.includes(methodName);
-      if (shouldHoist) {
-        // We've matched e.g. `.mock(...)` or similar call.
-        // Replace the initial `.` with `function __jestHoist(){jest.`
-        const hoistedFunctionName = this.nameManager.claimFreeName("__jestHoist");
-        this.hoistedFunctionNames.push(hoistedFunctionName);
-        this.tokens.replaceToken(`function ${hoistedFunctionName}(){${JEST_GLOBAL_NAME}.`);
-        this.tokens.copyToken();
-        this.tokens.copyToken();
-        this.rootTransformer.processBalancedCode();
-        this.tokens.copyExpectedToken(tt.parenR);
-        this.tokens.appendCode(";}");
-        followsNonHoistedJestCall = false;
-      } else {
-        // This is a non-hoisted method, so just transform the code as usual.
-        if (followsNonHoistedJestCall) {
-          // If we didn't hoist the previous call, we can leave the code as-is to chain off of the
-          // previous method call. It's important to preserve the code here because we don't know
-          // for sure that the method actually returned the jest object for chaining.
-          this.tokens.copyToken();
-        } else {
-          // If we hoisted the previous call, we know it returns the jest object back, so we insert
-          // the identifier `jest` to continue the chain.
-          this.tokens.replaceToken(`${JEST_GLOBAL_NAME}.`);
-        }
-        this.tokens.copyToken();
-        this.tokens.copyToken();
-        this.rootTransformer.processBalancedCode();
-        this.tokens.copyExpectedToken(tt.parenR);
-        followsNonHoistedJestCall = true;
-      }
-    }
-
-    return true;
-  }
-}

package/website/node_modules/sucrase/dist/esm/transformers/NumericSeparatorTransformer.js

@@ -1,20 +0,0 @@
-import {TokenType as tt} from "../parser/tokenizer/types";
-
-import Transformer from "./Transformer";
-
-export default class NumericSeparatorTransformer extends Transformer {
-  constructor( tokens) {
-    super();this.tokens = tokens;;
-  }
-
-  process() {
-    if (this.tokens.matches1(tt.num)) {
-      const code = this.tokens.currentTokenCode();
-      if (code.includes("_")) {
-        this.tokens.replaceToken(code.replace(/_/g, ""));
-        return true;
-      }
-    }
-    return false;
-  }
-}

package/website/node_modules/sucrase/dist/esm/transformers/OptionalCatchBindingTransformer.js

@@ -1,19 +0,0 @@
-
-import {TokenType as tt} from "../parser/tokenizer/types";
-
-import Transformer from "./Transformer";
-
-export default class OptionalCatchBindingTransformer extends Transformer {
-  constructor( tokens,  nameManager) {
-    super();this.tokens = tokens;this.nameManager = nameManager;;
-  }
-
-  process() {
-    if (this.tokens.matches2(tt._catch, tt.braceL)) {
-      this.tokens.copyToken();
-      this.tokens.appendCode(` (${this.nameManager.claimFreeName("e")})`);
-      return true;
-    }
-    return false;
-  }
-}

package/website/node_modules/sucrase/dist/esm/transformers/OptionalChainingNullishTransformer.js

@@ -1,155 +0,0 @@
-
-import {TokenType as tt} from "../parser/tokenizer/types";
-
-import Transformer from "./Transformer";
-
-/**
- * Transformer supporting the optional chaining and nullish coalescing operators.
- *
- * Tech plan here:
- * https://github.com/alangpierce/sucrase/wiki/Sucrase-Optional-Chaining-and-Nullish-Coalescing-Technical-Plan
- *
- * The prefix and suffix code snippets are handled by TokenProcessor, and this transformer handles
- * the operators themselves.
- */
-export default class OptionalChainingNullishTransformer extends Transformer {
-  constructor( tokens,  nameManager) {
-    super();this.tokens = tokens;this.nameManager = nameManager;;
-  }
-
-  process() {
-    if (this.tokens.matches1(tt.nullishCoalescing)) {
-      const token = this.tokens.currentToken();
-      if (this.tokens.tokens[token.nullishStartIndex].isAsyncOperation) {
-        this.tokens.replaceTokenTrimmingLeftWhitespace(", async () => (");
-      } else {
-        this.tokens.replaceTokenTrimmingLeftWhitespace(", () => (");
-      }
-      return true;
-    }
-    if (this.tokens.matches1(tt._delete)) {
-      const nextToken = this.tokens.tokenAtRelativeIndex(1);
-      if (nextToken.isOptionalChainStart) {
-        this.tokens.removeInitialToken();
-        return true;
-      }
-    }
-    const token = this.tokens.currentToken();
-    const chainStart = token.subscriptStartIndex;
-    if (
-      chainStart != null &&
-      this.tokens.tokens[chainStart].isOptionalChainStart &&
-      // Super subscripts can't be optional (since super is never null/undefined), and the syntax
-      // relies on the subscript being intact, so leave this token alone.
-      this.tokens.tokenAtRelativeIndex(-1).type !== tt._super
-    ) {
-      const param = this.nameManager.claimFreeName("_");
-      let arrowStartSnippet;
-      if (
-        chainStart > 0 &&
-        this.tokens.matches1AtIndex(chainStart - 1, tt._delete) &&
-        this.isLastSubscriptInChain()
-      ) {
-        // Delete operations are special: we already removed the delete keyword, and to still
-        // perform a delete, we need to insert a delete in the very last part of the chain, which
-        // in correct code will always be a property access.
-        arrowStartSnippet = `${param} => delete ${param}`;
-      } else {
-        arrowStartSnippet = `${param} => ${param}`;
-      }
-      if (this.tokens.tokens[chainStart].isAsyncOperation) {
-        arrowStartSnippet = `async ${arrowStartSnippet}`;
-      }
-      if (
-        this.tokens.matches2(tt.questionDot, tt.parenL) ||
-        this.tokens.matches2(tt.questionDot, tt.lessThan)
-      ) {
-        if (this.justSkippedSuper()) {
-          this.tokens.appendCode(".bind(this)");
-        }
-        this.tokens.replaceTokenTrimmingLeftWhitespace(`, 'optionalCall', ${arrowStartSnippet}`);
-      } else if (this.tokens.matches2(tt.questionDot, tt.bracketL)) {
-        this.tokens.replaceTokenTrimmingLeftWhitespace(`, 'optionalAccess', ${arrowStartSnippet}`);
-      } else if (this.tokens.matches1(tt.questionDot)) {
-        this.tokens.replaceTokenTrimmingLeftWhitespace(`, 'optionalAccess', ${arrowStartSnippet}.`);
-      } else if (this.tokens.matches1(tt.dot)) {
-        this.tokens.replaceTokenTrimmingLeftWhitespace(`, 'access', ${arrowStartSnippet}.`);
-      } else if (this.tokens.matches1(tt.bracketL)) {
-        this.tokens.replaceTokenTrimmingLeftWhitespace(`, 'access', ${arrowStartSnippet}[`);
-      } else if (this.tokens.matches1(tt.parenL)) {
-        if (this.justSkippedSuper()) {
-          this.tokens.appendCode(".bind(this)");
-        }
-        this.tokens.replaceTokenTrimmingLeftWhitespace(`, 'call', ${arrowStartSnippet}(`);
-      } else {
-        throw new Error("Unexpected subscript operator in optional chain.");
-      }
-      return true;
-    }
-    return false;
-  }
-
-  /**
-   * Determine if the current token is the last of its chain, so that we know whether it's eligible
-   * to have a delete op inserted.
-   *
-   * We can do this by walking forward until we determine one way or another. Each
-   * isOptionalChainStart token must be paired with exactly one isOptionalChainEnd token after it in
-   * a nesting way, so we can track depth and walk to the end of the chain (the point where the
-   * depth goes negative) and see if any other subscript token is after us in the chain.
-   */
-  isLastSubscriptInChain() {
-    let depth = 0;
-    for (let i = this.tokens.currentIndex() + 1; ; i++) {
-      if (i >= this.tokens.tokens.length) {
-        throw new Error("Reached the end of the code while finding the end of the access chain.");
-      }
-      if (this.tokens.tokens[i].isOptionalChainStart) {
-        depth++;
-      } else if (this.tokens.tokens[i].isOptionalChainEnd) {
-        depth--;
-      }
-      if (depth < 0) {
-        return true;
-      }
-
-      // This subscript token is a later one in the same chain.
-      if (depth === 0 && this.tokens.tokens[i].subscriptStartIndex != null) {
-        return false;
-      }
-    }
-  }
-
-  /**
-   * Determine if we are the open-paren in an expression like super.a()?.b.
-   *
-   * We can do this by walking backward to find the previous subscript. If that subscript was
-   * preceded by a super, then we must be the subscript after it, so if this is a call expression,
-   * we'll need to attach the right context.
-   */
-  justSkippedSuper() {
-    let depth = 0;
-    let index = this.tokens.currentIndex() - 1;
-    while (true) {
-      if (index < 0) {
-        throw new Error(
-          "Reached the start of the code while finding the start of the access chain.",
-        );
-      }
-      if (this.tokens.tokens[index].isOptionalChainStart) {
-        depth--;
-      } else if (this.tokens.tokens[index].isOptionalChainEnd) {
-        depth++;
-      }
-      if (depth < 0) {
-        return false;
-      }
-
-      // This subscript token is a later one in the same chain.
-      if (depth === 0 && this.tokens.tokens[index].subscriptStartIndex != null) {
-        return this.tokens.tokens[index - 1].type === tt._super;
-      }
-      index--;
-    }
-  }
-}

package/website/node_modules/sucrase/dist/esm/transformers/ReactDisplayNameTransformer.js

@@ -1,160 +0,0 @@
-
-
-import {IdentifierRole} from "../parser/tokenizer";
-import {TokenType as tt} from "../parser/tokenizer/types";
-
-
-import Transformer from "./Transformer";
-
-/**
- * Implementation of babel-plugin-transform-react-display-name, which adds a
- * display name to usages of React.createClass and createReactClass.
- */
-export default class ReactDisplayNameTransformer extends Transformer {
-  constructor(
-     rootTransformer,
-     tokens,
-     importProcessor,
-     options,
-  ) {
-    super();this.rootTransformer = rootTransformer;this.tokens = tokens;this.importProcessor = importProcessor;this.options = options;;
-  }
-
-  process() {
-    const startIndex = this.tokens.currentIndex();
-    if (this.tokens.identifierName() === "createReactClass") {
-      const newName =
-        this.importProcessor && this.importProcessor.getIdentifierReplacement("createReactClass");
-      if (newName) {
-        this.tokens.replaceToken(`(0, ${newName})`);
-      } else {
-        this.tokens.copyToken();
-      }
-      this.tryProcessCreateClassCall(startIndex);
-      return true;
-    }
-    if (
-      this.tokens.matches3(tt.name, tt.dot, tt.name) &&
-      this.tokens.identifierName() === "React" &&
-      this.tokens.identifierNameAtIndex(this.tokens.currentIndex() + 2) === "createClass"
-    ) {
-      const newName = this.importProcessor
-        ? this.importProcessor.getIdentifierReplacement("React") || "React"
-        : "React";
-      if (newName) {
-        this.tokens.replaceToken(newName);
-        this.tokens.copyToken();
-        this.tokens.copyToken();
-      } else {
-        this.tokens.copyToken();
-        this.tokens.copyToken();
-        this.tokens.copyToken();
-      }
-      this.tryProcessCreateClassCall(startIndex);
-      return true;
-    }
-    return false;
-  }
-
-  /**
-   * This is called with the token position at the open-paren.
-   */
-   tryProcessCreateClassCall(startIndex) {
-    const displayName = this.findDisplayName(startIndex);
-    if (!displayName) {
-      return;
-    }
-
-    if (this.classNeedsDisplayName()) {
-      this.tokens.copyExpectedToken(tt.parenL);
-      this.tokens.copyExpectedToken(tt.braceL);
-      this.tokens.appendCode(`displayName: '${displayName}',`);
-      this.rootTransformer.processBalancedCode();
-      this.tokens.copyExpectedToken(tt.braceR);
-      this.tokens.copyExpectedToken(tt.parenR);
-    }
-  }
-
-   findDisplayName(startIndex) {
-    if (startIndex < 2) {
-      return null;
-    }
-    if (this.tokens.matches2AtIndex(startIndex - 2, tt.name, tt.eq)) {
-      // This is an assignment (or declaration) and the LHS is either an identifier or a member
-      // expression ending in an identifier, so use that identifier name.
-      return this.tokens.identifierNameAtIndex(startIndex - 2);
-    }
-    if (
-      startIndex >= 2 &&
-      this.tokens.tokens[startIndex - 2].identifierRole === IdentifierRole.ObjectKey
-    ) {
-      // This is an object literal value.
-      return this.tokens.identifierNameAtIndex(startIndex - 2);
-    }
-    if (this.tokens.matches2AtIndex(startIndex - 2, tt._export, tt._default)) {
-      return this.getDisplayNameFromFilename();
-    }
-    return null;
-  }
-
-   getDisplayNameFromFilename() {
-    const filePath = this.options.filePath || "unknown";
-    const pathSegments = filePath.split("/");
-    const filename = pathSegments[pathSegments.length - 1];
-    const dotIndex = filename.lastIndexOf(".");
-    const baseFilename = dotIndex === -1 ? filename : filename.slice(0, dotIndex);
-    if (baseFilename === "index" && pathSegments[pathSegments.length - 2]) {
-      return pathSegments[pathSegments.length - 2];
-    } else {
-      return baseFilename;
-    }
-  }
-
-  /**
-   * We only want to add a display name when this is a function call containing
-   * one argument, which is an object literal without `displayName` as an
-   * existing key.
-   */
-   classNeedsDisplayName() {
-    let index = this.tokens.currentIndex();
-    if (!this.tokens.matches2(tt.parenL, tt.braceL)) {
-      return false;
-    }
-    // The block starts on the {, and we expect any displayName key to be in
-    // that context. We need to ignore other other contexts to avoid matching
-    // nested displayName keys.
-    const objectStartIndex = index + 1;
-    const objectContextId = this.tokens.tokens[objectStartIndex].contextId;
-    if (objectContextId == null) {
-      throw new Error("Expected non-null context ID on object open-brace.");
-    }
-
-    for (; index < this.tokens.tokens.length; index++) {
-      const token = this.tokens.tokens[index];
-      if (token.type === tt.braceR && token.contextId === objectContextId) {
-        index++;
-        break;
-      }
-
-      if (
-        this.tokens.identifierNameAtIndex(index) === "displayName" &&
-        this.tokens.tokens[index].identifierRole === IdentifierRole.ObjectKey &&
-        token.contextId === objectContextId
-      ) {
-        // We found a displayName key, so bail out.
-        return false;
-      }
-    }
-
-    if (index === this.tokens.tokens.length) {
-      throw new Error("Unexpected end of input when processing React class.");
-    }
-
-    // If we got this far, we know we have createClass with an object with no
-    // display name, so we want to proceed as long as that was the only argument.
-    return (
-      this.tokens.matches1AtIndex(index, tt.parenR) ||
-      this.tokens.matches2AtIndex(index, tt.comma, tt.parenR)
-    );
-  }
-}

package/website/node_modules/sucrase/dist/esm/transformers/ReactHotLoaderTransformer.js

@@ -1,69 +0,0 @@
-import {IdentifierRole, isTopLevelDeclaration} from "../parser/tokenizer";
-
-import Transformer from "./Transformer";
-
-export default class ReactHotLoaderTransformer extends Transformer {
-   __init() {this.extractedDefaultExportName = null}
-
-  constructor( tokens,  filePath) {
-    super();this.tokens = tokens;this.filePath = filePath;ReactHotLoaderTransformer.prototype.__init.call(this);;
-  }
-
-  setExtractedDefaultExportName(extractedDefaultExportName) {
-    this.extractedDefaultExportName = extractedDefaultExportName;
-  }
-
-  getPrefixCode() {
-    return `
-      (function () {
-        var enterModule = require('react-hot-loader').enterModule;
-        enterModule && enterModule(module);
-      })();`
-      .replace(/\s+/g, " ")
-      .trim();
-  }
-
-  getSuffixCode() {
-    const topLevelNames = new Set();
-    for (const token of this.tokens.tokens) {
-      if (
-        !token.isType &&
-        isTopLevelDeclaration(token) &&
-        token.identifierRole !== IdentifierRole.ImportDeclaration
-      ) {
-        topLevelNames.add(this.tokens.identifierNameForToken(token));
-      }
-    }
-    const namesToRegister = Array.from(topLevelNames).map((name) => ({
-      variableName: name,
-      uniqueLocalName: name,
-    }));
-    if (this.extractedDefaultExportName) {
-      namesToRegister.push({
-        variableName: this.extractedDefaultExportName,
-        uniqueLocalName: "default",
-      });
-    }
-    return `
-;(function () {
-  var reactHotLoader = require('react-hot-loader').default;
-  var leaveModule = require('react-hot-loader').leaveModule;
-  if (!reactHotLoader) {
-    return;
-  }
-${namesToRegister
-  .map(
-    ({variableName, uniqueLocalName}) =>
-      `  reactHotLoader.register(${variableName}, "${uniqueLocalName}", ${JSON.stringify(
-        this.filePath || "",
-      )});`,
-  )
-  .join("\n")}
-  leaveModule(module);
-})();`;
-  }
-
-  process() {
-    return false;
-  }
-}