dismantle 0.2.0

package/src/transform-block.ts

@@ -0,0 +1,115 @@
+import type * as babel from '@babel/core';
+import type * as t from '@babel/types';
+import { splitBlock } from './split';
+import type { DirectiveDefinition, StateContext } from './types';
+
+function getValidDirectiveFromString(
+  ctx: StateContext,
+  string: string,
+): DirectiveDefinition | undefined {
+  for (let i = 0, len = ctx.options.directives.length; i < len; i++) {
+    const current = ctx.options.directives[i];
+    if (current.value === string) {
+      return current;
+    }
+  }
+  return undefined;
+}
+
+function getDefinitionFromDirectives(
+  ctx: StateContext,
+  path: babel.NodePath<t.BlockStatement>,
+): DirectiveDefinition | undefined {
+  for (let i = 0, len = path.node.directives.length; i < len; i++) {
+    const statement = path.node.directives[i].value.value;
+    const directive = getValidDirectiveFromString(ctx, statement);
+    if (directive) {
+      return directive;
+    }
+  }
+  return undefined;
+}
+
+function getDefinitionFromFauxDirectives(
+  ctx: StateContext,
+  path: babel.NodePath<t.BlockStatement>,
+): DirectiveDefinition | undefined {
+  for (let i = 0, len = path.node.body.length; i < len; i++) {
+    const statement = path.node.body[i];
+    if (
+      statement.type === 'ExpressionStatement' &&
+      statement.expression.type === 'StringLiteral'
+    ) {
+      const directive = getValidDirectiveFromString(
+        ctx,
+        statement.expression.value,
+      );
+      if (directive) {
+        return directive;
+      }
+    } else {
+      break;
+    }
+  }
+  return undefined;
+}
+
+function getDirectiveDefinitionFromBlock(
+  ctx: StateContext,
+  path: babel.NodePath<t.BlockStatement>,
+): DirectiveDefinition | undefined {
+  const parent = path.getFunctionParent();
+  if (parent && !parent.node.async) {
+    return undefined;
+  }
+  return (
+    getDefinitionFromDirectives(ctx, path) ||
+    getDefinitionFromFauxDirectives(ctx, path)
+  );
+}
+
+function cleanBlockForDirectives(
+  path: babel.NodePath<t.BlockStatement>,
+  definition: DirectiveDefinition,
+): void {
+  const newDirectives: t.Directive[] = [];
+  for (let i = 0, len = path.node.directives.length; i < len; i++) {
+    const current = path.node.directives[i];
+    if (current.value.value !== definition.value) {
+      newDirectives.push(current);
+    }
+  }
+  path.node.directives = newDirectives;
+}
+
+function cleanBlockForFauxDirectives(
+  path: babel.NodePath<t.BlockStatement>,
+  definition: DirectiveDefinition,
+): void {
+  const body = path.get('body');
+  for (let i = 0, len = body.length; i < len; i++) {
+    const statement = body[i];
+    if (
+      statement.node.type === 'ExpressionStatement' &&
+      statement.node.expression.type === 'StringLiteral'
+    ) {
+      if (statement.node.expression.value === definition.value) {
+        statement.remove();
+        return;
+      }
+    }
+  }
+}
+
+export function transformBlock(
+  ctx: StateContext,
+  path: babel.NodePath<t.BlockStatement>,
+): void {
+  const definition = getDirectiveDefinitionFromBlock(ctx, path);
+  if (!definition) {
+    return;
+  }
+  cleanBlockForDirectives(path, definition);
+  cleanBlockForFauxDirectives(path, definition);
+  splitBlock(ctx, path, definition);
+}

package/src/transform-call.ts

@@ -0,0 +1,100 @@
+import type * as babel from '@babel/core';
+import * as t from '@babel/types';
+import { splitExpression, splitFunction } from './split';
+import type { FunctionDefinition, StateContext } from './types';
+import { isPathValid, unwrapNode } from './utils/unwrap';
+
+function getFunctionDefinitionFromPropName(
+  definitions: FunctionDefinition[],
+  propName: string,
+): FunctionDefinition | undefined {
+  for (let i = 0, len = definitions.length; i < len; i++) {
+    const def = definitions[i];
+    if (def.source.kind === 'default' && propName === 'default') {
+      return def;
+    }
+    if (def.source.kind === 'named' && propName === def.source.name) {
+      return def;
+    }
+  }
+  return undefined;
+}
+
+function getFunctionDefinitionFromCallee(
+  ctx: StateContext,
+  path: babel.NodePath<t.CallExpression>,
+): FunctionDefinition | undefined {
+  const callee = path.node.callee;
+  const id = unwrapNode(callee, t.isIdentifier);
+  if (id) {
+    const binding = path.scope.getBindingIdentifier(id.name);
+    if (binding) {
+      return ctx.registrations.identifiers.get(binding);
+    }
+    return undefined;
+  }
+  const memberExpr = unwrapNode(callee, t.isMemberExpression);
+  if (
+    memberExpr &&
+    !memberExpr.computed &&
+    t.isIdentifier(memberExpr.property)
+  ) {
+    const object = unwrapNode(memberExpr.object, t.isIdentifier);
+    if (object) {
+      const binding = path.scope.getBindingIdentifier(object.name);
+      if (binding) {
+        const definitions = ctx.registrations.namespaces.get(binding);
+        if (definitions) {
+          return getFunctionDefinitionFromPropName(
+            definitions,
+            memberExpr.property.name,
+          );
+        }
+      }
+    }
+  }
+  return undefined;
+}
+
+function isValidFunction(
+  node: t.Node,
+): node is t.ArrowFunctionExpression | t.FunctionExpression {
+  return t.isArrowFunctionExpression(node) || t.isFunctionExpression(node);
+}
+
+function isSkippableFunction(node: t.Expression): boolean {
+  if (node.leadingComments) {
+    for (let i = 0, len = node.leadingComments.length; i < len; i++) {
+      if (/^@dismantle skip$/.test(node.leadingComments[i].value)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+export function transformCall(
+  ctx: StateContext,
+  path: babel.NodePath<t.CallExpression>,
+): void {
+  const definition = getFunctionDefinitionFromCallee(ctx, path);
+  if (!definition) {
+    return;
+  }
+  const args = path.get('arguments');
+  const expr = args[0];
+  if (isPathValid(expr, t.isExpression)) {
+    if (isSkippableFunction(expr.node)) {
+      return;
+    }
+    const replacement = isPathValid(expr, isValidFunction)
+      ? splitFunction(ctx, expr, definition)
+      : splitExpression(ctx, expr, definition);
+
+    if (definition.preserve) {
+      expr.replaceWith(t.addComment(replacement, 'leading', '@dismantle skip'));
+    } else {
+      path.replaceWith(replacement);
+    }
+  }
+}

package/src/types.ts

@@ -0,0 +1,73 @@
+import type * as babel from '@babel/core';
+import type * as t from '@babel/types';
+import type * as path from 'node:path';
+
+export interface NamedImportDefinition {
+  kind: 'named';
+  name: string;
+  source: string;
+}
+
+export interface DefaultImportDefinition {
+  kind: 'default';
+  source: string;
+}
+
+export type ImportDefinition = DefaultImportDefinition | NamedImportDefinition;
+
+export interface DirectiveDefinition {
+  value: string;
+  target: ImportDefinition;
+  pure?: boolean;
+}
+
+export interface FunctionDefinition {
+  source: ImportDefinition;
+  target: ImportDefinition;
+  preserve?: boolean;
+  pure?: boolean;
+}
+
+export interface Options {
+  key: string;
+  mode: 'server' | 'client';
+  env: 'production' | 'development';
+  directives: DirectiveDefinition[];
+  functions: FunctionDefinition[];
+}
+
+export interface ModuleDefinition {
+  source: string;
+  kind: 'default' | 'named' | 'namespace';
+  local: string;
+  imported?: string;
+}
+
+export interface CodeOutput {
+  code: babel.BabelFileResult['code'];
+  map: babel.BabelFileResult['map'];
+}
+
+export interface StateContext {
+  id: string;
+  path: path.ParsedPath;
+  imports: Map<string, t.Identifier>;
+  virtual: {
+    count: number;
+  };
+  blocks: {
+    hash: string;
+    count: number;
+  };
+  bindings: Map<string, ModuleDefinition>;
+  options: Options;
+  onVirtualFile: (
+    path: string,
+    content: CodeOutput,
+    mode: 'entry' | 'root' | 'none',
+  ) => void;
+  registrations: {
+    identifiers: Map<t.Identifier, FunctionDefinition>;
+    namespaces: Map<t.Identifier, FunctionDefinition[]>;
+  };
+}

package/src/utils/assert.ts

@@ -0,0 +1,5 @@
+export default function assert(cond: unknown, error: string): asserts cond {
+  if (!cond) {
+    throw new Error(error);
+  }
+}

package/src/utils/errors.ts

@@ -0,0 +1,21 @@
+import type * as babel from '@babel/core';
+
+export function unexpectedType<T>(
+  path: babel.NodePath<T>,
+  received: string,
+  expected: string,
+): Error {
+  return path.buildCodeFrameError(
+    `Unexpected '${received}' (Expected: ${expected})`,
+  );
+}
+
+export function unexpectedArgumentLength<T>(
+  path: babel.NodePath<T>,
+  received: number,
+  expected: number,
+): Error {
+  return path.buildCodeFrameError(
+    `Unexpected argument length of ${received} (Expected: at least ${expected})`,
+  );
+}

package/src/utils/generator-shim.ts

@@ -0,0 +1,22 @@
+import _generator from '@babel/generator';
+import type * as t from '@babel/types';
+import type { CodeOutput } from '../types';
+
+type GeneratorShim = typeof _generator;
+
+// https://github.com/babel/babel/issues/15269
+const generator: GeneratorShim =
+  typeof _generator !== 'function'
+    ? (_generator as unknown as { default: GeneratorShim }).default
+    : _generator;
+
+export function generateCode(id: string, node: t.Node): CodeOutput {
+  const result = generator(node, {
+    sourceMaps: true,
+    sourceFileName: id,
+  });
+  return {
+    code: result.code,
+    map: result.map,
+  };
+}

package/src/utils/get-descriptive-name.ts

@@ -0,0 +1,42 @@
+import type { NodePath } from '@babel/core';
+
+export function getDescriptiveName(
+  path: NodePath,
+  defaultName: string,
+): string {
+  let current: NodePath | null = path;
+  while (current) {
+    switch (current.node.type) {
+      case 'FunctionDeclaration':
+      case 'FunctionExpression': {
+        if (current.node.id) {
+          return current.node.id.name;
+        }
+        break;
+      }
+      case 'VariableDeclarator': {
+        if (current.node.id.type === 'Identifier') {
+          return current.node.id.name;
+        }
+        break;
+      }
+      case 'ClassPrivateMethod':
+      case 'ClassMethod':
+      case 'ObjectMethod': {
+        switch (current.node.key.type) {
+          case 'Identifier':
+            return current.node.key.name;
+          case 'PrivateName':
+            return current.node.key.id.name;
+          default:
+            break;
+        }
+        break;
+      }
+      default:
+        break;
+    }
+    current = current.parentPath;
+  }
+  return defaultName;
+}

package/src/utils/get-foreign-bindings.ts

@@ -0,0 +1,60 @@
+import type * as babel from '@babel/core';
+import * as t from '@babel/types';
+
+function isForeignBinding(
+  source: babel.NodePath,
+  current: babel.NodePath,
+  name: string,
+  mode: 'block' | 'function',
+): boolean {
+  if (current.scope.hasGlobal(name)) {
+    return false;
+  }
+  if (source === current) {
+    return true;
+  }
+  if (current.scope.hasOwnBinding(name)) {
+    if (mode === 'block') {
+      const binding = current.scope.getBinding(name);
+      return !!binding && binding.kind === 'param';
+    }
+    return false;
+  }
+  if (current.parentPath) {
+    return isForeignBinding(source, current.parentPath, name, mode);
+  }
+  return true;
+}
+
+function isInTypescript(path: babel.NodePath): boolean {
+  let parent = path.parentPath;
+  while (parent) {
+    if (t.isTypeScript(parent.node) && !t.isExpression(parent.node)) {
+      return true;
+    }
+    parent = parent.parentPath;
+  }
+  return false;
+}
+
+export default function getForeignBindings(
+  path: babel.NodePath,
+  mode: 'block' | 'function' | 'expression',
+): Set<string> {
+  const identifiers = new Set<string>();
+  path.traverse({
+    ReferencedIdentifier(p) {
+      // Check identifiers that aren't in a TS expression
+      if (
+        !isInTypescript(p) &&
+        (mode === 'expression'
+          ? !path.scope.hasGlobal(p.node.name)
+          : isForeignBinding(path, p, p.node.name, mode))
+      ) {
+        identifiers.add(p.node.name);
+      }
+    },
+  });
+
+  return identifiers;
+}

package/src/utils/get-identifiers-from-lval.ts

@@ -0,0 +1,44 @@
+import * as t from '@babel/types';
+
+function getIdentifiersFromArrayPattern(node: t.ArrayPattern): string[] {
+  const ids: string[] = [];
+  for (let i = 0, len = node.elements.length; i < len; i++) {
+    const el = node.elements[i];
+    if (el) {
+      ids.push(...getIdentifiersFromLVal(el));
+    }
+  }
+  return ids;
+}
+
+function getIdentifiersFromObjectPattern(node: t.ObjectPattern): string[] {
+  const ids: string[] = [];
+  for (let i = 0, len = node.properties.length; i < len; i++) {
+    const el = node.properties[i];
+    if (el) {
+      if (el.type === 'RestElement') {
+        ids.push(...getIdentifiersFromLVal(el));
+      } else if (t.isLVal(el.value)) {
+        ids.push(...getIdentifiersFromLVal(el.value));
+      }
+    }
+  }
+  return ids;
+}
+
+export function getIdentifiersFromLVal(node: t.LVal): string[] {
+  switch (node.type) {
+    case 'Identifier':
+      return [node.name];
+    case 'ArrayPattern':
+      return getIdentifiersFromArrayPattern(node);
+    case 'AssignmentPattern':
+      return getIdentifiersFromLVal(node.left);
+    case 'ObjectPattern':
+      return getIdentifiersFromObjectPattern(node);
+    case 'RestElement':
+      return getIdentifiersFromLVal(node.argument);
+    default:
+      return [];
+  }
+}

package/src/utils/get-import-identifier.ts

@@ -0,0 +1,23 @@
+import type * as babel from '@babel/core';
+import { addDefault, addNamed } from '@babel/helper-module-imports';
+import type * as t from '@babel/types';
+import type { ImportDefinition, StateContext } from '../types';
+
+export function getImportIdentifier(
+  state: StateContext,
+  path: babel.NodePath,
+  registration: ImportDefinition,
+): t.Identifier {
+  const name = registration.kind === 'named' ? registration.name : 'default';
+  const target = `${registration.source}[${name}]`;
+  const current = state.imports.get(target);
+  if (current) {
+    return current;
+  }
+  const newID =
+    registration.kind === 'named'
+      ? addNamed(path, registration.name, registration.source)
+      : addDefault(path, registration.source);
+  state.imports.set(target, newID);
+  return newID;
+}

package/src/utils/get-import-specifier-name.ts

@@ -0,0 +1,10 @@
+import type * as t from '@babel/types';
+
+export function getImportSpecifierName(node: t.ImportSpecifier) {
+  switch (node.imported.type) {
+    case 'Identifier':
+      return node.imported.name;
+    case 'StringLiteral':
+      return node.imported.value;
+  }
+}

package/src/utils/get-module-definition.ts

@@ -0,0 +1,53 @@
+import type * as babel from '@babel/core';
+import * as t from '@babel/types';
+import type { ModuleDefinition } from '../types';
+import { getImportSpecifierName } from './get-import-specifier-name';
+import { isPathValid } from './unwrap';
+
+export function getModuleDefinition(
+  path: babel.NodePath,
+): ModuleDefinition | undefined {
+  if (
+    !(
+      isPathValid(path, t.isImportSpecifier) ||
+      isPathValid(path, t.isImportDefaultSpecifier) ||
+      isPathValid(path, t.isImportNamespaceSpecifier)
+    )
+  ) {
+    return undefined;
+  }
+  const parent =
+    path.getStatementParent() as babel.NodePath<t.ImportDeclaration>;
+  const source = parent.node.source.value;
+  switch (path.node.type) {
+    case 'ImportDefaultSpecifier':
+      return {
+        source,
+        kind: 'default',
+        local: path.node.local.name,
+      };
+    case 'ImportNamespaceSpecifier':
+      return {
+        source,
+        kind: 'namespace',
+        local: path.node.local.name,
+      };
+    case 'ImportSpecifier': {
+      const imported = getImportSpecifierName(path.node);
+      if (imported === 'default') {
+        return {
+          source,
+          kind: 'default',
+          local: path.node.local.name,
+          imported: '',
+        };
+      }
+      return {
+        source,
+        kind: 'named',
+        local: path.node.local.name,
+        imported,
+      };
+    }
+  }
+}

package/src/utils/get-root-statement-path.ts

@@ -0,0 +1,14 @@
+import type * as babel from '@babel/core';
+import * as t from '@babel/types';
+
+export function getRootStatementPath(path: babel.NodePath): babel.NodePath {
+  let current = path.parentPath;
+  while (current) {
+    const next = current.parentPath;
+    if (next && t.isProgram(next.node)) {
+      return current;
+    }
+    current = next;
+  }
+  return path;
+}

package/src/utils/register-import-specifiers.ts

@@ -0,0 +1,77 @@
+import type * as babel from '@babel/core';
+import * as t from '@babel/types';
+import type { FunctionDefinition, StateContext } from '../types';
+import { getImportSpecifierName } from './get-import-specifier-name';
+
+function registerImportSpecifier(
+  ctx: StateContext,
+  node:
+    | t.ImportSpecifier
+    | t.ImportDefaultSpecifier
+    | t.ImportNamespaceSpecifier,
+  definition: FunctionDefinition,
+): void {
+  if (t.isImportSpecifier(node)) {
+    if (node.importKind === 'type' || node.importKind === 'typeof') {
+      return;
+    }
+    const key = getImportSpecifierName(node);
+    if (
+      (definition.source.kind === 'named' && key === definition.source.name) ||
+      (definition.source.kind === 'default' && key === 'default')
+    ) {
+      ctx.registrations.identifiers.set(node.local, definition);
+    }
+  }
+  if (
+    t.isImportDefaultSpecifier(node) &&
+    definition.source.kind === 'default'
+  ) {
+    ctx.registrations.identifiers.set(node.local, definition);
+  }
+  if (t.isImportNamespaceSpecifier(node)) {
+    let current = ctx.registrations.namespaces.get(node.local);
+    if (!current) {
+      current = [];
+    }
+    current.push(definition);
+    ctx.registrations.namespaces.set(node.local, current);
+  }
+}
+
+function registerImportDeclarationByDefinition(
+  ctx: StateContext,
+  path: babel.NodePath<t.ImportDeclaration>,
+  definition: FunctionDefinition,
+): void {
+  for (let i = 0, len = path.node.specifiers.length; i < len; i++) {
+    const specifier = path.node.specifiers[i];
+    registerImportSpecifier(ctx, specifier, definition);
+  }
+}
+
+export function registerImportSpecifiers(
+  ctx: StateContext,
+  programPath: babel.NodePath<t.Program>,
+): void {
+  const len = ctx.options.functions.length;
+  if (!len) {
+    return;
+  }
+  programPath.traverse({
+    ImportDeclaration(path) {
+      if (
+        path.node.importKind === 'type' ||
+        path.node.importKind === 'typeof'
+      ) {
+        return;
+      }
+      for (let i = 0; i < len; i++) {
+        const func = ctx.options.functions[i];
+        if (func.source.source === path.node.source.value) {
+          registerImportDeclarationByDefinition(ctx, path, func);
+        }
+      }
+    },
+  });
+}