flow-parser 0.320.0 → 0.321.0

package/oxidized/oxidized-src/estree/StripFlowTypes.js

@@ -1,158 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.transformProgram = transformProgram;
-
-var _SimpleTransform = require("../transform/SimpleTransform");
-
-const nodeWith = _SimpleTransform.SimpleTransform.nodeWith;
-
-function transformProgram(program, _options) {
-  return _SimpleTransform.SimpleTransform.transformProgram(program, {
-    transform(node) {
-      switch (node.type) {
-        case 'AsExpression':
-        case 'AsConstExpression':
-        case 'TypeCastExpression':
-          {
-            return node.expression;
-          }
-
-        case 'CallExpression':
-        case 'NewExpression':
-          {
-            if (node.typeArguments != null) {
-              return nodeWith(node, {
-                typeArguments: null
-              });
-            }
-
-            return node;
-          }
-
-        case 'ObjectPattern':
-        case 'ArrayPattern':
-        case 'Identifier':
-          {
-            if (node.typeAnnotation != null) {
-              return nodeWith(node, {
-                typeAnnotation: null
-              });
-            }
-
-            return node;
-          }
-
-        case 'DeclareClass':
-        case 'DeclareFunction':
-        case 'DeclareInterface':
-        case 'DeclareModule':
-        case 'DeclareModuleExports':
-        case 'DeclareNamespace':
-        case 'DeclareOpaqueType':
-        case 'DeclareTypeAlias':
-        case 'DeclareVariable':
-        case 'InterfaceDeclaration':
-        case 'OpaqueType':
-        case 'TypeAlias':
-          {
-            return null;
-          }
-
-        case 'FunctionDeclaration':
-        case 'ArrowFunctionExpression':
-        case 'FunctionExpression':
-          {
-            const newParams = [];
-
-            for (let i = 0; i < node.params.length; i++) {
-              if (i === 0 && node.params[0].type === 'Identifier' && node.params[0].name === 'this') {
-                continue;
-              }
-
-              let param = node.params[i];
-
-              if (param.type === 'AssignmentPattern') {
-                param = param.left;
-              }
-
-              if (param.optional === true) {
-                param = nodeWith(param, {
-                  optional: false
-                });
-              }
-
-              newParams.push(param);
-            }
-
-            return nodeWith(node, {
-              params: newParams,
-              returnType: null,
-              typeParameters: null,
-              predicate: null
-            });
-          }
-
-        case 'ClassDeclaration':
-        case 'ClassExpression':
-          {
-            return nodeWith(node, {
-              typeParameters: null,
-              superTypeArguments: null,
-              implements: [],
-              decorators: []
-            });
-          }
-
-        case 'PropertyDefinition':
-          {
-            return nodeWith(node, {
-              typeAnnotation: null,
-              variance: null,
-              declare: false,
-              optional: false
-            });
-          }
-
-        case 'ImportDeclaration':
-          {
-            if (node.importKind === 'type' || node.importKind === 'typeof') {
-              return null;
-            }
-
-            const nonTypeSpecifiers = node.specifiers.filter(s => s.type !== 'ImportSpecifier' || s.importKind !== 'type' && s.importKind !== 'typeof');
-
-            if (nonTypeSpecifiers.length === 0) {
-              return null;
-            }
-
-            if (nonTypeSpecifiers.length === node.specifiers.length) {
-              return node;
-            }
-
-            return nodeWith(node, {
-              specifiers: nonTypeSpecifiers
-            });
-          }
-
-        case 'ExportAllDeclaration':
-        case 'ExportNamedDeclaration':
-          {
-            if (node.exportKind === 'type') {
-              return null;
-            }
-
-            return node;
-          }
-
-        default:
-          {
-            return node;
-          }
-      }
-    }
-
-  });
-}

package/oxidized/oxidized-src/estree/StripFlowTypesForBabel.js

@@ -1,191 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.transformProgram = transformProgram;
-
-var _SimpleTransform = require("../transform/SimpleTransform");
-
-var _createSyntaxError = require("../utils/createSyntaxError");
-
-const nodeWith = _SimpleTransform.SimpleTransform.nodeWith;
-const EMPTY_PARENT = null;
-
-function createSimpleGenericTypeAnnotation(name, nodeForLoc) {
-  return {
-    type: 'GenericTypeAnnotation',
-    id: {
-      type: 'Identifier',
-      name,
-      optional: false,
-      typeAnnotation: null,
-      loc: nodeForLoc.loc,
-      range: nodeForLoc.range,
-      parent: EMPTY_PARENT
-    },
-    typeParameters: null,
-    loc: nodeForLoc.loc,
-    range: nodeForLoc.range,
-    parent: nodeForLoc.parent
-  };
-}
-
-function createAnyTypeAnnotation(node) {
-  return {
-    type: 'AnyTypeAnnotation',
-    loc: node.loc,
-    range: node.range,
-    parent: node.parent
-  };
-}
-
-function declareVariableDeclarator(id, node) {
-  return {
-    type: 'VariableDeclarator',
-    id,
-    init: null,
-    loc: node.loc,
-    range: node.range,
-    parent: EMPTY_PARENT
-  };
-}
-
-function mapDeclareEnum(node) {
-  const id = nodeWith(node.id, {
-    typeAnnotation: {
-      type: 'TypeAnnotation',
-      typeAnnotation: createAnyTypeAnnotation(node.body),
-      loc: node.body.loc,
-      range: node.body.range,
-      parent: EMPTY_PARENT
-    }
-  });
-  return {
-    type: 'DeclareVariable',
-    kind: 'const',
-    declarations: [declareVariableDeclarator(id, node)],
-    implicitDeclare: false,
-    loc: node.loc,
-    range: node.range,
-    parent: node.parent
-  };
-}
-
-function mapDeclareNamespace(node) {
-  const id = nodeWith(node.id, {
-    typeAnnotation: {
-      type: 'TypeAnnotation',
-      typeAnnotation: createAnyTypeAnnotation(node.body),
-      loc: node.body.loc,
-      range: node.body.range,
-      parent: EMPTY_PARENT
-    }
-  });
-  return {
-    type: 'DeclareVariable',
-    kind: 'const',
-    declarations: [declareVariableDeclarator(id, node)],
-    implicitDeclare: false,
-    loc: node.loc,
-    range: node.range,
-    parent: node.parent
-  };
-}
-
-function mapFunction(node) {
-  if (node.params.length !== 0 && node.params[0].name === 'this') {
-    return nodeWith(node, {
-      params: node.params.slice(1)
-    });
-  }
-
-  return node;
-}
-
-function mapQualifiedTypeofIdentifier(node) {
-  return {
-    type: 'QualifiedTypeIdentifier',
-    qualification: node.qualification.type === 'QualifiedTypeofIdentifier' ? mapQualifiedTypeofIdentifier(node.qualification) : node.qualification,
-    id: node.id,
-    loc: node.loc,
-    range: node.range,
-    parent: node.parent
-  };
-}
-
-function transformProgram(program, _options) {
-  return _SimpleTransform.SimpleTransform.transformProgram(program, {
-    transform(node) {
-      switch (node.type) {
-        case 'SymbolTypeAnnotation':
-          {
-            return createSimpleGenericTypeAnnotation('symbol', node);
-          }
-
-        case 'BigIntTypeAnnotation':
-          {
-            return createSimpleGenericTypeAnnotation('bigint', node);
-          }
-
-        case 'ObjectTypeAnnotation':
-          {
-            const shouldStrip = node.properties.some(prop => prop.type === 'ObjectTypeMappedTypeProperty');
-
-            if (shouldStrip) {
-              return createAnyTypeAnnotation(node);
-            }
-
-            return node;
-          }
-
-        case 'ObjectTypeMappedTypeProperty':
-          {
-            throw (0, _createSyntaxError.createSyntaxError)(node, `Invalid AST structure, ObjectTypeMappedTypeProperty found outside of an ObjectTypeAnnotation`);
-          }
-
-        case 'IndexedAccessType':
-        case 'OptionalIndexedAccessType':
-        case 'KeyofTypeAnnotation':
-        case 'ConditionalTypeAnnotation':
-        case 'InferTypeAnnotation':
-        case 'TupleTypeLabeledElement':
-        case 'TupleTypeSpreadElement':
-        case 'ComponentTypeAnnotation':
-        case 'HookTypeAnnotation':
-        case 'TypeOperator':
-        case 'TypePredicate':
-          {
-            return createAnyTypeAnnotation(node);
-          }
-
-        case 'QualifiedTypeofIdentifier':
-          {
-            return mapQualifiedTypeofIdentifier(node);
-          }
-
-        case 'DeclareEnum':
-          {
-            return mapDeclareEnum(node);
-          }
-
-        case 'DeclareNamespace':
-          {
-            return mapDeclareNamespace(node);
-          }
-
-        case 'FunctionDeclaration':
-        case 'FunctionExpression':
-          {
-            return mapFunction(node);
-          }
-
-        default:
-          {
-            return node;
-          }
-      }
-    }
-
-  });
-}