one/dist/esm/vite/plugins/clientTreeShakePlugin.native.js

One is a new React Framework that makes Vite serve both native and web.

import { extname, relative } from "path";
import BabelGenerate from "@babel/generator";
import { parse } from "@babel/parser";
import BabelTraverse from "@babel/traverse";
import { deadCodeElimination, findReferencedIdentifiers } from "babel-dead-code-elimination";
import { EMPTY_LOADER_STRING, makeLoaderRouteIdStub } from "../constants.native.js";
function _instanceof(left, right) {
  if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
    return !!right[Symbol.hasInstance](left);
  } else {
    return left instanceof right;
  }
}
var traverse = BabelTraverse["default"] || BabelTraverse;
var generate = BabelGenerate["default"] || BabelGenerate;
function collectTypeImports(ast) {
  var typeImports = [];
  traverse(ast, {
    ImportDeclaration(path) {
      if (path.node.importKind === "type") {
        typeImports.push(path.node);
      }
    }
  });
  return typeImports;
}
function restoreTypeImports(ast, typeImports) {
  if (typeImports.length === 0) return;
  var existingSources = /* @__PURE__ */new Set();
  traverse(ast, {
    ImportDeclaration(path) {
      if (path.node.importKind === "type") {
        existingSources.add(path.node.source.value);
      }
    }
  });
  var _iteratorNormalCompletion = true,
    _didIteratorError = false,
    _iteratorError = void 0;
  try {
    for (var _iterator = typeImports[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
      var typeImport = _step.value;
      if (!existingSources.has(typeImport.source.value)) {
        ast.program.body.unshift(typeImport);
      }
    }
  } catch (err) {
    _didIteratorError = true;
    _iteratorError = err;
  } finally {
    try {
      if (!_iteratorNormalCompletion && _iterator.return != null) {
        _iterator.return();
      }
    } finally {
      if (_didIteratorError) {
        throw _iteratorError;
      }
    }
  }
}
var clientTreeShakePlugin = function (opts) {
  var _ref;
  var runtime = (_ref = opts === null || opts === void 0 ? void 0 : opts.runtime) !== null && _ref !== void 0 ? _ref : "vite";
  return {
    name: "one-client-tree-shake",
    enforce: "pre",
    ...(runtime === "vite" && {
      applyToEnvironment(env) {
        return env.name === "client" || env.name === "ios" || env.name === "android";
      }
    }),
    transform: {
      order: "pre",
      async handler(code, id, settings) {
        var _this_environment;
        if (runtime === "vite" && ((_this_environment = this.environment) === null || _this_environment === void 0 ? void 0 : _this_environment.name) === "ssr") {
          return;
        }
        if (!/\.(js|jsx|ts|tsx)/.test(extname(id))) {
          return;
        }
        if (/node_modules/.test(id)) {
          return;
        }
        var out = await transformTreeShakeClient(code, id, process.cwd());
        return out;
      }
    }
  };
};
async function transformTreeShakeClient(code, id, root) {
  if (!/generateStaticParams|loader/.test(code)) {
    return;
  }
  var ast;
  try {
    ast = parse(code, {
      sourceType: "module",
      plugins: ["typescript", "jsx"]
    });
  } catch (error) {
    var errorMessage = _instanceof(error, Error) ? error.message : String(error);
    console.warn(`[one] Skipping tree shaking for ${id} due to syntax error:`, errorMessage);
    return;
  }
  var referenced;
  try {
    referenced = findReferencedIdentifiers(ast);
  } catch (error) {
    var errorMessage1 = _instanceof(error, Error) ? error.message : String(error);
    console.warn(`[one] Skipping tree shaking for ${id} due to identifier analysis error:`, errorMessage1);
    return;
  }
  var removed = {
    loader: false,
    generateStaticParams: false
  };
  try {
    traverse(ast, {
      ExportNamedDeclaration(path) {
        if (path.node.declaration && path.node.declaration.type === "FunctionDeclaration") {
          if (!path.node.declaration.id) return;
          var functionName = path.node.declaration.id.name;
          if (functionName === "loader" || functionName === "generateStaticParams") {
            path.remove();
            removed[functionName] = true;
          }
        } else if (path.node.declaration && path.node.declaration.type === "VariableDeclaration") {
          path.node.declaration.declarations.forEach(function (declarator, index) {
            if (declarator.id.type === "Identifier" && (declarator.id.name === "loader" || declarator.id.name === "generateStaticParams")) {
              var declaration = path.get("declaration.declarations." + index);
              if (!Array.isArray(declaration) && declaration) {
                ;
                declaration.remove();
                removed[declarator.id.name] = true;
              }
            }
          });
        }
      }
    });
  } catch (error) {
    var errorMessage2 = _instanceof(error, Error) ? error.message : String(error);
    console.warn(`[one] Skipping tree shaking for ${id} due to traversal error:`, errorMessage2);
    return;
  }
  var removedFunctions = Object.keys(removed).filter(function (key) {
    return removed[key];
  });
  if (removedFunctions.length) {
    try {
      var typeImports = collectTypeImports(ast);
      deadCodeElimination(ast, referenced);
      restoreTypeImports(ast, typeImports);
      var out = generate(ast, {
        retainLines: true
      });
      var codeOut = out.code + "\n\n" + removedFunctions.map(function (key) {
        if (key === "loader") {
          if (root) {
            var fromRoot = relative(root, id).replace(/\\/g, "/");
            var routeId = "./" + fromRoot.replace(/^app\//, "");
            return makeLoaderRouteIdStub(routeId);
          }
          return EMPTY_LOADER_STRING;
        }
        return `export function generateStaticParams() {};`;
      }).join("\n");
      console.info(` \u{1F9F9} [one]      ${relative(process.cwd(), id)} removed ${removedFunctions.length} server-only exports`);
      return {
        code: codeOut,
        map: out.map
      };
    } catch (error) {
      var errorMessage3 = _instanceof(error, Error) ? error.message : String(error);
      console.warn(`[one] Skipping tree shaking for ${id} due to code generation error:`, errorMessage3);
      return;
    }
  }
}
export { clientTreeShakePlugin, transformTreeShakeClient };
//# sourceMappingURL=clientTreeShakePlugin.native.js.map