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 } from "../constants.native.js";
function _instanceof(left, right) {
  return right != null && typeof Symbol < "u" && right[Symbol.hasInstance] ? !!right[Symbol.hasInstance](left) : left instanceof right;
}
var traverse = BabelTraverse.default || BabelTraverse,
  generate = BabelGenerate.default || BabelGenerate;
function collectTypeImports(ast) {
  var typeImports = [];
  return traverse(ast, {
    ImportDeclaration(path) {
      path.node.importKind === "type" && typeImports.push(path.node);
    }
  }), typeImports;
}
function restoreTypeImports(ast, typeImports) {
  if (typeImports.length !== 0) {
    var existingSources = /* @__PURE__ */new Set();
    traverse(ast, {
      ImportDeclaration(path) {
        path.node.importKind === "type" && existingSources.add(path.node.source.value);
      }
    });
    var _iteratorNormalCompletion = !0,
      _didIteratorError = !1,
      _iteratorError = void 0;
    try {
      for (var _iterator = typeImports[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
        var typeImport = _step.value;
        existingSources.has(typeImport.source.value) || ast.program.body.unshift(typeImport);
      }
    } catch (err) {
      _didIteratorError = !0, _iteratorError = err;
    } finally {
      try {
        !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
      } finally {
        if (_didIteratorError) throw _iteratorError;
      }
    }
  }
}
var clientTreeShakePlugin = function () {
  return {
    name: "one-client-tree-shake",
    enforce: "pre",
    applyToEnvironment(env) {
      return env.name === "client" || env.name === "ios" || env.name === "android";
    },
    transform: {
      order: "pre",
      async handler(code, id, settings) {
        if (this.environment.name !== "ssr" && /\.(js|jsx|ts|tsx)/.test(extname(id)) && !/node_modules/.test(id)) {
          var out = await transformTreeShakeClient(code, id);
          return out;
        }
      }
    }
  };
};
async function transformTreeShakeClient(code, id) {
  if (/generateStaticParams|loader/.test(code)) {
    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: !1,
      generateStaticParams: !1
    };
    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;
            (functionName === "loader" || functionName === "generateStaticParams") && (path.remove(), removed[functionName] = !0);
          } else 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);
              !Array.isArray(declaration) && declaration && (declaration.remove(), removed[declarator.id.name] = !0);
            }
          });
        }
      });
    } 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),
        codeOut = out.code + `

` + removedFunctions.map(function (key) {
          return key === "loader" ? EMPTY_LOADER_STRING : "export function generateStaticParams() {};";
        }).join(`
`);
      return console.info(` \u{1F9F9} [one]      ${relative(process.cwd(), id)} removed ${removedFunctions.length} server-only exports`), {
        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