one
Version:
One is a new React Framework that makes Vite serve both native and web.
224 lines (222 loc) • 8.24 kB
JavaScript
;
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_path = require("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.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 = import_traverse.default["default"] || import_traverse.default;
var generate = import_generator.default["default"] || import_generator.default;
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((0, import_path.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 = (0, import_parser.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 = (0, import_babel_dead_code_elimination.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);
(0, import_babel_dead_code_elimination.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 = (0, import_path.relative)(root, id).replace(/\\/g, "/");
var 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_path.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;
}
}
}
//# sourceMappingURL=clientTreeShakePlugin.native.js.map