one 2.10.0 → 2.11.0

package/dist/cjs/cli/iosLinkSetAnalysis.cjs

@@ -0,0 +1,329 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var iosLinkSetAnalysis_exports = {};
+__export(iosLinkSetAnalysis_exports, {
+	analyzeModule: () => analyzeModule,
+	catalogNames: () => catalogNames,
+	emptyUsage: () => emptyUsage,
+	groupsForUsage: () => groupsForUsage,
+	keyPattern: () => keyPattern,
+	mightUseGroups: () => mightUseGroups
+});
+module.exports = __toCommonJS(iosLinkSetAnalysis_exports);
+var import_oxc_parser = require("oxc-parser");
+const emptyUsage = () => ({
+	names: /* @__PURE__ */ new Set(),
+	keys: /* @__PURE__ */ new Set(),
+	all: false
+});
+const oneSource = /^one(?:\/.*)?$/;
+const valueTs = /* @__PURE__ */ new Set([
+	"TSAsExpression",
+	"TSSatisfiesExpression",
+	"TSNonNullExpression",
+	"TSTypeAssertion",
+	"TSInstantiationExpression",
+	"TSParameterProperty",
+	"TSEnumDeclaration",
+	"TSEnumBody",
+	"TSEnumMember",
+	"TSModuleDeclaration",
+	"TSModuleBlock",
+	"TSExportAssignment",
+	"TSImportEqualsDeclaration"
+]);
+function catalogNames(catalog) {
+	const names = /* @__PURE__ */ new Map();
+	const keys = /* @__PURE__ */ new Map();
+	const add = (map, name, group) => map.set(name, [...map.get(name) ?? [], group]);
+	for (const [group, entry] of Object.entries(catalog.groups)) {
+		for (const component of entry.components) add(names, component.replace(/^OneNative/, ""), group);
+		for (const use of entry.uses ?? []) add(names, use, group);
+		for (const key of [
+			...entry.modifiers ?? [],
+			...entry.slots ?? [],
+			...entry.values ?? [],
+			...entry.hybrids,
+			...entry.components
+		]) add(keys, key, group);
+	}
+	return {
+		names,
+		keys
+	};
+}
+function mightUseGroups(code, keys, pattern = keyPattern(keys)) {
+	return /['"]one(?:\/[^'"]*)?['"]/.test(code) || pattern.test(code);
+}
+function keyPattern(keys) {
+	const list = [...keys];
+	return list.length ? new RegExp(`(?<![\\w$])(?:${list.join("|")})(?![\\w$])`) : /(?!)/;
+}
+function isNode(value) {
+	return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+function analyzeModule(code, filename, keys, usage) {
+	const lang = /\.tsx$/.test(filename) ? "tsx" : /\.[cm]?ts$/.test(filename) ? "ts" : "jsx";
+	let program;
+	try {
+		const parsed = (0, import_oxc_parser.parseSync)(filename, code, {
+			lang,
+			sourceType: "unambiguous"
+		});
+		if (parsed.errors.length) throw new Error(parsed.errors[0].message);
+		program = parsed.program;
+	} catch {
+		if (/['"]one(?:\/[^'"]*)?['"]/.test(code)) usage.all = true;
+		for (const key of keys) if (new RegExp(`(?<![\\w$])${key}(?![\\w$])`).test(code)) usage.keys.add(key);
+		return;
+	}
+	const bindings = /* @__PURE__ */ new Map();
+	const unwrap = (node) => {
+		let current = node;
+		while (current.type === "ParenthesizedExpression" || current.type === "ChainExpression" || current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSNonNullExpression" || current.type === "TSTypeAssertion") current = current.expression;
+		return current;
+	};
+	const staticName = (node) => {
+		if (node.computed) {
+			if (node.property.type === "Literal" && typeof node.property.value === "string") return node.property.value;
+			if (node.property.type === "TemplateLiteral" && !node.property.expressions.length) return node.property.quasis[0].value.cooked;
+			return void 0;
+		}
+		return node.property.name;
+	};
+	const step = (held, name) => held === "module" && name === "One" ? "one" : held === "one" && name === "iOS" ? "ios" : void 0;
+	const heldBy = (raw) => {
+		const node = unwrap(raw);
+		switch (node.type) {
+			case "Identifier": return bindings.get(node.name);
+			case "MemberExpression": {
+				const object = heldBy(node.object);
+				const name = staticName(node);
+				return object && name !== void 0 ? step(object, name) : void 0;
+			}
+			case "AwaitExpression": return node.argument.type === "ImportExpression" && importedOne(node.argument) ? "module" : void 0;
+			case "ImportExpression": return void 0;
+			case "CallExpression": {
+				const callee = unwrap(node.callee);
+				return callee.type === "Identifier" && callee.name === "require" && node.arguments.length === 1 && node.arguments[0].type === "Literal" && oneSource.test(String(node.arguments[0].value)) ? "module" : void 0;
+			}
+			default: return void 0;
+		}
+	};
+	const importedOne = (node) => node.source.type === "Literal" && oneSource.test(String(node.source.value));
+	const bindPattern = (pattern, held, record) => {
+		switch (pattern.type) {
+			case "Identifier":
+				bindings.set(pattern.name, held);
+				return;
+			case "AssignmentPattern":
+				bindPattern(pattern.left, held, record);
+				return;
+			case "ObjectPattern":
+				for (const property of pattern.properties) {
+					if (property.type === "RestElement") {
+						bindPattern(property.argument, held, record);
+						continue;
+					}
+					let name;
+					if (!property.computed && property.key.type === "Identifier") name = property.key.name;
+					else if (property.key.type === "Literal") name = String(property.key.value);
+					if (name === void 0) {
+						if (record) usage.all = true;
+						continue;
+					}
+					if (record) usage.names.add(name);
+					const next = step(held, name);
+					if (next) bindPattern(property.value, next, record);
+				}
+				return;
+			default: if (record) usage.all = true;
+		}
+	};
+	const sites = [];
+	const collect = (node) => {
+		if (node.type === "ImportDeclaration" && importedOne(node)) {
+			for (const specifier of node.specifiers) {
+				if (specifier.type === "ImportNamespaceSpecifier") bindings.set(specifier.local.name, "module");
+				else if (specifier.type === "ImportDefaultSpecifier") bindings.set(specifier.local.name, "one");
+				else {
+					const imported = specifier.imported.name ?? String(specifier.imported.value);
+					if (imported === "One") bindings.set(specifier.local.name, "one");
+					else usage.names.add(imported);
+				}
+			}
+		} else if ((node.type === "ExportNamedDeclaration" || node.type === "ExportAllDeclaration") && node.source && importedOne(node)) {
+			if (node.type === "ExportAllDeclaration") usage.all = true;
+			else for (const specifier of node.specifiers) usage.names.add(specifier.local.name ?? String(specifier.local.value));
+		} else if (node.type === "VariableDeclarator" && node.init) sites.push(node);
+		else if (node.type === "AssignmentExpression" && node.operator === "=") sites.push(node);
+	};
+	const visitAll = (node, enter) => {
+		enter(node);
+		for (const [key, value] of Object.entries(node)) {
+			if (key === "typeAnnotation" || key === "returnType" || key === "typeParameters" || key === "typeArguments") continue;
+			for (const child of Array.isArray(value) ? value : [value]) if (isNode(child) && (!child.type.startsWith("TS") || valueTs.has(child.type))) visitAll(child, enter);
+		}
+	};
+	visitAll(program, collect);
+	for (let size = -1; size !== bindings.size;) {
+		size = bindings.size;
+		for (const site of sites) {
+			const target = site.type === "VariableDeclarator" ? site.id : site.left;
+			const source = site.type === "VariableDeclarator" ? site.init : site.right;
+			const held = heldBy(source);
+			if (!held) continue;
+			if (target.type === "Identifier") bindings.set(target.name, held);
+			else bindPattern(target, held, false);
+		}
+	}
+	const safeParent = (node, parent, key) => !parent || parent.type === "ParenthesizedExpression" || parent.type === "ChainExpression" || parent.type === "TSAsExpression" || parent.type === "TSSatisfiesExpression" || parent.type === "TSNonNullExpression" || parent.type === "TSTypeAssertion" || parent.type === "AwaitExpression" || parent.type === "MemberExpression" && key === "object" || parent.type === "VariableDeclarator" && key === "init" || parent.type === "AssignmentExpression" && key === "right" && parent.operator === "=" && unwrap(parent.left).type === "Identifier" || parent.type === "ExpressionStatement" && key === "expression";
+	const visit = (node, parent, key) => {
+		if (node.type.startsWith("TS") && !valueTs.has(node.type)) return;
+		switch (node.type) {
+			case "ImportDeclaration": return;
+			case "ExportNamedDeclaration":
+				if (node.source) return;
+				break;
+			case "ExportSpecifier":
+				if (bindings.has(node.local.name)) usage.all = true;
+				return;
+			case "ExportAllDeclaration": return;
+			case "VariableDeclarator": {
+				const held = node.init ? heldBy(node.init) : void 0;
+				if (held && node.id.type !== "Identifier") bindPattern(node.id, held, true);
+				else visitPattern(node.id);
+				if (node.init) visit(node.init, node, "init");
+				return;
+			}
+			case "AssignmentExpression": {
+				const held = heldBy(node.right);
+				if (held && node.operator === "=" && node.left.type !== "Identifier" && node.left.type !== "MemberExpression") bindPattern(node.left, held, true);
+				else visitPattern(node.left);
+				visit(node.right, node, "right");
+				return;
+			}
+			case "MemberExpression": {
+				const object = heldBy(node.object);
+				const name = staticName(node);
+				if (object) {
+					if (name === void 0) usage.all = true;
+					else usage.names.add(name);
+				}
+				if (!node.computed) {
+					visit(node.object, node, "object");
+					return;
+				}
+				break;
+			}
+			case "JSXOpeningElement": {
+				let name = node.name;
+				const path = [];
+				while (name.type === "JSXMemberExpression") {
+					path.unshift(name.property.name);
+					name = name.object;
+				}
+				let held = name.type === "JSXIdentifier" ? bindings.get(name.name) : void 0;
+				for (const part of path) {
+					if (!held) break;
+					usage.names.add(part);
+					held = step(held, part);
+				}
+				for (const attribute of node.attributes) visit(attribute, node, "attributes");
+				return;
+			}
+			case "JSXAttribute":
+				if (node.name.type === "JSXIdentifier" && keys.has(node.name.name)) usage.keys.add(node.name.name);
+				if (node.value) visit(node.value, node, "value");
+				return;
+			case "JSXMemberExpression":
+			case "JSXIdentifier":
+			case "JSXNamespacedName": return;
+			case "Property":
+			case "PropertyDefinition":
+			case "MethodDefinition":
+			case "TSAbstractPropertyDefinition": {
+				if (!node.computed) {
+					const name = node.key.type === "Identifier" ? node.key.name : node.key.type === "Literal" ? String(node.key.value) : void 0;
+					if (name !== void 0 && keys.has(name)) usage.keys.add(name);
+				} else visit(node.key, node, "key");
+				if (node.value) visit(node.value, node, "value");
+				return;
+			}
+			case "Literal":
+				if (typeof node.value === "string" && keys.has(node.value)) usage.keys.add(node.value);
+				break;
+			case "TemplateLiteral":
+				if (!node.expressions.length && keys.has(node.quasis[0].value.cooked)) usage.keys.add(node.quasis[0].value.cooked);
+				break;
+			case "Identifier":
+				if (bindings.has(node.name) && !safeParent(node, parent, key)) usage.all = true;
+				return;
+			case "ImportExpression":
+				if (importedOne(node) && !(parent?.type === "AwaitExpression")) usage.all = true;
+				break;
+			case "CallExpression":
+				if (heldBy(node) && !safeParent(node, parent, key)) usage.all = true;
+				break;
+		}
+		if (node.type === "MemberExpression" && !node.computed) return;
+		for (const [childKey, value] of Object.entries(node)) {
+			if (childKey === "typeAnnotation" || childKey === "returnType" || childKey === "typeParameters" || childKey === "typeArguments") continue;
+			for (const child of Array.isArray(value) ? value : [value]) if (isNode(child)) visit(child, node, childKey);
+		}
+	};
+	function visitPattern(pattern) {
+		switch (pattern.type) {
+			case "AssignmentPattern":
+				visitPattern(pattern.left);
+				visit(pattern.right, pattern, "right");
+				return;
+			case "ObjectPattern":
+				for (const property of pattern.properties) {
+					if (property.type === "RestElement") visitPattern(property.argument);
+					else {
+						if (property.computed) visit(property.key, property, "key");
+						else if (property.key.type === "Identifier" && keys.has(property.key.name)) usage.keys.add(property.key.name);
+						visitPattern(property.value);
+					}
+				}
+				return;
+			case "ArrayPattern":
+				for (const element of pattern.elements) if (element) visitPattern(element);
+				return;
+			case "RestElement":
+				visitPattern(pattern.argument);
+				return;
+			case "MemberExpression":
+				visit(pattern, void 0, "");
+				return;
+		}
+	}
+	visit(program, void 0, "");
+}
+function groupsForUsage(usage, catalog) {
+	if (usage.all) return Object.keys(catalog.groups);
+	const { names, keys } = catalogNames(catalog);
+	const reached = /* @__PURE__ */ new Set();
+	for (const name of usage.names) for (const group of names.get(name) ?? []) reached.add(group);
+	for (const key of usage.keys) for (const group of keys.get(key) ?? []) reached.add(group);
+	return Object.keys(catalog.groups).filter((group) => reached.has(group));
+}