one/dist/cjs/vite/plugins/clientTreeShakePlugin.cjs

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

var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all) __defProp(target, name, {
    get: all[name],
    enumerable: true
  });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
      get: () => from[key],
      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
    });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
  value: mod,
  enumerable: true
}) : target, mod));
var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
  value: true
}), mod);
var clientTreeShakePlugin_exports = {};
__export(clientTreeShakePlugin_exports, {
  clientTreeShakePlugin: () => clientTreeShakePlugin,
  transformTreeShakeClient: () => transformTreeShakeClient
});
module.exports = __toCommonJS(clientTreeShakePlugin_exports);
var import_node_path = require("node:path");
var import_generator = __toESM(require("@babel/generator"), 1);
var import_parser = require("@babel/parser");
var import_traverse = __toESM(require("@babel/traverse"), 1);
var import_babel_dead_code_elimination = require("babel-dead-code-elimination");
var import_constants = require("../constants.cjs");
const traverse = import_traverse.default["default"] || import_traverse.default;
const generate = import_generator.default["default"] || import_generator.default;
function collectTypeImports(ast) {
  const 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;
  const existingSources = /* @__PURE__ */new Set();
  traverse(ast, {
    ImportDeclaration(path) {
      if (path.node.importKind === "type") {
        existingSources.add(path.node.source.value);
      }
    }
  });
  for (const typeImport of typeImports) {
    if (!existingSources.has(typeImport.source.value)) {
      ast.program.body.unshift(typeImport);
    }
  }
}
const clientTreeShakePlugin = opts => {
  const runtime = opts?.runtime ?? "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) {
        if (runtime === "vite" && this.environment?.name === "ssr") {
          return;
        }
        if (!/\.(js|jsx|ts|tsx)/.test((0, import_node_path.extname)(id))) {
          return;
        }
        if (/node_modules/.test(id)) {
          return;
        }
        const out = await transformTreeShakeClient(code, id, process.cwd());
        return out;
      }
    }
  };
};
async function transformTreeShakeClient(code, id, root) {
  if (!/generateStaticParams|loader/.test(code)) {
    return;
  }
  let ast;
  try {
    ast = (0, import_parser.parse)(code, {
      sourceType: "module",
      plugins: ["typescript", "jsx"]
    });
  } catch (error) {
    const errorMessage = error instanceof Error ? error.message : String(error);
    console.warn(`[one] Skipping tree shaking for ${id} due to syntax error:`, errorMessage);
    return;
  }
  let referenced;
  try {
    referenced = (0, import_babel_dead_code_elimination.findReferencedIdentifiers)(ast);
  } catch (error) {
    const errorMessage = error instanceof Error ? error.message : String(error);
    console.warn(`[one] Skipping tree shaking for ${id} due to identifier analysis error:`, errorMessage);
    return;
  }
  const 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;
          const 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((declarator, index) => {
            if (declarator.id.type === "Identifier" && (declarator.id.name === "loader" || declarator.id.name === "generateStaticParams")) {
              const declaration = path.get("declaration.declarations." + index);
              if (!Array.isArray(declaration) && declaration) {
                ;
                declaration.remove();
                removed[declarator.id.name] = true;
              }
            }
          });
        }
      }
    });
  } catch (error) {
    const errorMessage = error instanceof Error ? error.message : String(error);
    console.warn(`[one] Skipping tree shaking for ${id} due to traversal error:`, errorMessage);
    return;
  }
  const removedFunctions = Object.keys(removed).filter(key => removed[key]);
  if (removedFunctions.length) {
    try {
      const typeImports = collectTypeImports(ast);
      (0, import_babel_dead_code_elimination.deadCodeElimination)(ast, referenced);
      restoreTypeImports(ast, typeImports);
      const out = generate(ast, {
        retainLines: true
      });
      const codeOut = out.code + "\n\n" + removedFunctions.map(key => {
        if (key === "loader") {
          if (root) {
            const fromRoot = (0, import_node_path.relative)(root, id).replace(/\\/g, "/");
            const routeId = "./" + fromRoot.replace(/^app\//, "");
            return (0, import_constants.makeLoaderRouteIdStub)(routeId);
          }
          return import_constants.EMPTY_LOADER_STRING;
        }
        return `export function generateStaticParams() {};`;
      }).join("\n");
      console.info(` \u{1F9F9} [one]      ${(0, import_node_path.relative)(process.cwd(), id)} removed ${removedFunctions.length} server-only exports`);
      return {
        code: codeOut,
        map: out.map
      };
    } catch (error) {
      const errorMessage = error instanceof Error ? error.message : String(error);
      console.warn(`[one] Skipping tree shaking for ${id} due to code generation error:`, errorMessage);
      return;
    }
  }
}