@tamagui/static 2.7.7 → 3.0.0-beta.1093.1

package/dist/cjs/zero/graph.cjs

@@ -0,0 +1,208 @@
+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(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var graph_exports = {};
+__export(graph_exports, {
+	checkZeroGraph: () => checkZeroGraph,
+	erasedExportEscape: () => erasedExportEscape,
+	formatZeroGraphFailure: () => formatZeroGraphFailure,
+	formatZeroViolations: () => formatZeroViolations,
+	isForbiddenZeroModuleId: () => isForbiddenZeroModuleId,
+	isTamaguiModuleId: () => isTamaguiModuleId,
+	offsetToLineColumn: () => offsetToLineColumn,
+	owningPackageOf: () => owningPackageOf,
+	owningPackageOfDir: () => owningPackageOfDir,
+	sortZeroViolations: () => sortZeroViolations,
+	writeZeroGraphReceipt: () => writeZeroGraphReceipt,
+	writeZeroViolationReport: () => writeZeroViolationReport
+});
+module.exports = __toCommonJS(graph_exports);
+var import_compiler_core = require("@tamagui/compiler-core");
+var import_node_fs = require("node:fs");
+var import_node_path = __toESM(require("node:path"), 1);
+const ALLOWED_ZERO_MODULE = /animated-number/;
+const owningPackageCache = /* @__PURE__ */ new Map();
+function owningPackageOf(id) {
+	const clean = id.split(/[?#]/, 1)[0];
+	if (!clean || clean.startsWith("\0") || !import_node_path.default.isAbsolute(clean)) return null;
+	return owningPackageOfDir(import_node_path.default.dirname(clean));
+}
+function owningPackageOfDir(from) {
+	if (!from || !import_node_path.default.isAbsolute(from)) return null;
+	let dir = from;
+	const visited = [];
+	while (true) {
+		const cached = owningPackageCache.get(dir);
+		if (cached !== void 0) {
+			for (const seen of visited) owningPackageCache.set(seen, cached);
+			return cached;
+		}
+		visited.push(dir);
+		const manifest = import_node_path.default.join(dir, "package.json");
+		if ((0, import_node_fs.existsSync)(manifest)) {
+			let owner = null;
+			try {
+				owner = {
+					name: JSON.parse((0, import_node_fs.readFileSync)(manifest, "utf8")).name ?? null,
+					manifest
+				};
+			} catch {
+				owner = {
+					name: null,
+					manifest
+				};
+			}
+			for (const seen of visited) owningPackageCache.set(seen, owner);
+			return owner;
+		}
+		const parent = import_node_path.default.dirname(dir);
+		if (parent === dir) {
+			for (const seen of visited) owningPackageCache.set(seen, null);
+			return null;
+		}
+		dir = parent;
+	}
+}
+function isTamaguiModuleId(id, ownManifest) {
+	const owner = owningPackageOf(id);
+	if (!owner?.name) return false;
+	if (ownManifest && owner.manifest === ownManifest) return false;
+	return owner.name === "tamagui" || owner.name.startsWith("@tamagui/");
+}
+function isForbiddenZeroModuleId(id, ownManifest) {
+	if (!isTamaguiModuleId(id, ownManifest)) return false;
+	return !ALLOWED_ZERO_MODULE.test(id);
+}
+function shortestChain(target, entries, importersOf) {
+	const entrySet = new Set(entries);
+	const seen = /* @__PURE__ */ new Set([target]);
+	const queue = [[target]];
+	let longest = [target];
+	while (queue.length) {
+		const chain = queue.shift();
+		const head = chain[0];
+		if (entrySet.has(head)) return chain;
+		if (chain.length > longest.length) longest = chain;
+		for (const importer of importersOf.get(head) ?? []) {
+			if (seen.has(importer)) continue;
+			seen.add(importer);
+			queue.push([importer, ...chain]);
+		}
+	}
+	return longest;
+}
+function checkZeroGraph(input) {
+	const importersOf = new Map(input.importerEdges);
+	for (const module2 of input.modules) {
+		if (!importersOf.has(module2.id)) importersOf.set(module2.id, module2.importers ?? []);
+	}
+	const ownManifest = input.root ? owningPackageOfDir(input.root)?.manifest ?? null : null;
+	const tamaguiModules = input.modules.map((module2) => module2.id).filter((id) => isTamaguiModuleId(id, ownManifest)).sort();
+	const forbidden = tamaguiModules.filter((id) => isForbiddenZeroModuleId(id, ownManifest)).map((id) => ({
+		id,
+		chain: shortestChain(id, input.entries, importersOf),
+		owner: owningPackageOf(id)?.name ?? ""
+	}));
+	return {
+		tamaguiModules,
+		forbidden
+	};
+}
+function formatZeroGraphFailure(receipt) {
+	const lines = [`[tamagui zero-runtime] ${receipt.integration} zero entry graph contains ${receipt.forbidden.length} forbidden Tamagui module(s)`, ""];
+	for (const entry of receipt.forbidden) {
+		lines.push(entry.owner ? `${entry.id} (package ${entry.owner})` : entry.id);
+		lines.push(entry.chain.length > 1 ? `  ${entry.chain.join("\n    -> ")}` : `  (this bundler exposed no importer edges for that module)`);
+	}
+	lines.push("");
+	lines.push(import_compiler_core.ZERO_FAILURE_FOOTER);
+	return lines.join("\n");
+}
+function writeZeroGraphReceipt(outDir, name, receipt) {
+	(0, import_node_fs.mkdirSync)(outDir, { recursive: true });
+	const file = import_node_path.default.join(outDir, `${name}.graph.json`);
+	(0, import_node_fs.writeFileSync)(file, `${JSON.stringify(receipt, null, 2)}
+`);
+	return file;
+}
+function sortZeroViolations(sites) {
+	return [...sites].sort((left, right) => (left.file < right.file ? -1 : left.file > right.file ? 1 : 0) || left.line - right.line || left.column - right.column || left.rule - right.rule || (left.message < right.message ? -1 : left.message > right.message ? 1 : 0));
+}
+function formatZeroViolations(sites) {
+	const sorted = sortZeroViolations(sites);
+	const lines = [`[tamagui zero-runtime] build failed with ${sorted.length} violations`, ""];
+	for (const site of sorted) {
+		lines.push(`Rule ${site.rule} ${site.code}`);
+		lines.push(`${site.file}:${site.line}:${site.column}${site.component ? ` ${site.component}` : ""}`);
+		lines.push(`  ${site.message}`);
+		lines.push("");
+	}
+	lines.push(import_compiler_core.ZERO_FAILURE_FOOTER);
+	return lines.join("\n");
+}
+function writeZeroViolationReport(outDir, name, report) {
+	(0, import_node_fs.mkdirSync)(outDir, { recursive: true });
+	const file = import_node_path.default.join(outDir, `${name}.violations.json`);
+	(0, import_node_fs.writeFileSync)(file, `${JSON.stringify({
+		integration: report.integration,
+		mode: report.mode,
+		count: report.violations.length,
+		violations: sortZeroViolations(report.violations)
+	}, null, 2)}
+`);
+	return file;
+}
+function erasedExportEscape(input) {
+	for (const [moduleId, names] of input.erasedExports) {
+		if (names.length === 0) continue;
+		if (!input.importersOf.has(moduleId)) {
+			return `[tamagui zero-runtime] ${input.integration} erased the exported definition(s) ${names.join(", ")} from ${moduleId}, and then could not find that module in its own graph, so nothing proved the erasure was safe.
+
+${import_compiler_core.ZERO_FAILURE_FOOTER}`;
+		}
+		const untransformed = (input.importersOf.get(moduleId) ?? []).filter((importer) => !input.transformed.has(importer));
+		if (untransformed.length === 0) continue;
+		return `[tamagui zero-runtime] ${input.integration} erased the exported definition(s) ${names.join(", ")} from ${moduleId}, but ${untransformed.length} importer(s) in this entry graph were never zero-transformed and may still reference them:
+  ${untransformed.join("\n  ")}
+
+${import_compiler_core.ZERO_FAILURE_FOOTER}`;
+	}
+	return null;
+}
+function offsetToLineColumn(source, offset) {
+	let line = 1;
+	let lineStart = 0;
+	for (let index = 0; index < offset && index < source.length; index++) {
+		if (source.charCodeAt(index) === 10) {
+			line++;
+			lineStart = index + 1;
+		}
+	}
+	return {
+		line,
+		column: offset - lineStart + 1
+	};
+}

package/dist/cjs/zero/identity.cjs

@@ -0,0 +1,60 @@
+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 identity_exports = {};
+__export(identity_exports, {
+	ZERO_COMPILER_VERSION: () => ZERO_COMPILER_VERSION,
+	canonicalizeBridgeManifest: () => canonicalizeBridgeManifest,
+	hashBridgeManifest: () => hashBridgeManifest,
+	hashZeroIdentity: () => hashZeroIdentity
+});
+module.exports = __toCommonJS(identity_exports);
+var import_compiler_core = require("@tamagui/compiler-core");
+var import_node_crypto = require("node:crypto");
+const ZERO_COMPILER_VERSION = `zero-1/plan-${import_compiler_core.LOWERED_MODULE_PLAN_VERSION}`;
+function hashZeroIdentity(identity) {
+	const canonical = {
+		runtimeLiteral: identity.runtimeLiteral,
+		target: identity.target,
+		configGeneration: identity.configGeneration,
+		cssHash: identity.cssHash,
+		compilerVersion: identity.compilerVersion,
+		islandEntries: [...identity.islandEntries].sort(),
+		bridgeManifestHash: identity.bridgeManifestHash,
+		islandOutputHashes: Object.fromEntries(Object.entries(identity.islandOutputHashes).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0))
+	};
+	return (0, import_node_crypto.createHash)("sha256").update(JSON.stringify(canonical)).digest("hex").slice(0, 24);
+}
+function canonicalizeBridgeManifest(manifest) {
+	if (Array.isArray(manifest)) {
+		return manifest.map((entry) => canonicalizeBridgeManifest(entry));
+	}
+	if (manifest && typeof manifest === "object") {
+		const sorted = {};
+		for (const key of Object.keys(manifest).sort()) {
+			sorted[key] = canonicalizeBridgeManifest(manifest[key]);
+		}
+		return sorted;
+	}
+	return manifest;
+}
+function hashBridgeManifest(manifest) {
+	return (0, import_node_crypto.createHash)("sha256").update(JSON.stringify(canonicalizeBridgeManifest(manifest))).digest("hex").slice(0, 16);
+}

package/dist/cjs/zero/index.cjs

@@ -0,0 +1,33 @@
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var zero_exports = {};
+__export(zero_exports, { isTamaguiSpecifier: () => import_compiler_core.isTamaguiSpecifier });
+module.exports = __toCommonJS(zero_exports);
+var import_compiler_core = require("@tamagui/compiler-core");
+__reExport(zero_exports, require("./artifact.cjs"), module.exports);
+__reExport(zero_exports, require("./graph.cjs"), module.exports);
+__reExport(zero_exports, require("./identity.cjs"), module.exports);
+__reExport(zero_exports, require("./islands.cjs"), module.exports);
+__reExport(zero_exports, require("./options.cjs"), module.exports);
+__reExport(zero_exports, require("./ownership.cjs"), module.exports);
+__reExport(zero_exports, require("./theme.cjs"), module.exports);
+__reExport(zero_exports, require("./transform.cjs"), module.exports);

package/dist/cjs/zero/islands.cjs

@@ -0,0 +1,234 @@
+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(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var islands_exports = {};
+__export(islands_exports, {
+	ISLAND_EXTERNAL_GLOBALS: () => ISLAND_EXTERNAL_GLOBALS,
+	ISLAND_EXTERNAL_GLOBAL_PATHS: () => ISLAND_EXTERNAL_GLOBAL_PATHS,
+	ISLAND_REGISTRY_KEY: () => ISLAND_REGISTRY_KEY,
+	ISLAND_RUNTIME_KEY: () => ISLAND_RUNTIME_KEY,
+	generateIslandEntrySource: () => generateIslandEntrySource,
+	generateIslandLoaderSource: () => generateIslandLoaderSource,
+	mergeIslandBridges: () => mergeIslandBridges,
+	writeIslandModules: () => writeIslandModules
+});
+module.exports = __toCommonJS(islands_exports);
+var import_node_fs = require("node:fs");
+var import_node_path = __toESM(require("node:path"), 1);
+const ISLAND_RUNTIME_KEY = "__tamagui_island_runtime__";
+const ISLAND_REGISTRY_KEY = "__tamagui_islands__";
+function writeIfChanged(file, content) {
+	(0, import_node_fs.mkdirSync)(import_node_path.default.dirname(file), { recursive: true });
+	let existing = null;
+	try {
+		existing = (0, import_node_fs.readFileSync)(file, "utf8");
+	} catch {
+		existing = null;
+	}
+	if (existing !== content) (0, import_node_fs.writeFileSync)(file, content);
+}
+function importPath(from, to) {
+	const relative = import_node_path.default.relative(import_node_path.default.dirname(from), to).replace(/\\/g, "/");
+	return relative.startsWith(".") ? relative : `./${relative}`;
+}
+function generateIslandLoaderSource(input) {
+	return `// generated by @tamagui/static zero-runtime. do not edit.
+import * as React from 'react'
+import * as ReactDOM from 'react-dom'
+import * as JSXRuntime from 'react/jsx-runtime'
+
+const ISLAND_ID = ${JSON.stringify(input.island.id)}
+const ISLAND_SRC = ${JSON.stringify(input.scriptUrl)}
+const CSS_HREF = ${JSON.stringify(input.cssHref)}
+const INTEGRATION = ${JSON.stringify(input.integration)}
+
+function sharedRuntime() {
+  const scope = globalThis
+  if (!scope[${JSON.stringify(ISLAND_RUNTIME_KEY)}]) {
+    scope[${JSON.stringify(ISLAND_RUNTIME_KEY)}] = {
+      react: React,
+      reactDom: ReactDOM,
+      jsxRuntime: JSXRuntime,
+    }
+  }
+  if (!scope[${JSON.stringify(ISLAND_REGISTRY_KEY)}]) {
+    scope[${JSON.stringify(ISLAND_REGISTRY_KEY)}] = {}
+  }
+  return scope
+}
+
+// The one accepted runtime recovery in zero-runtime mode, and it is loud on
+// purpose. "Unimported" is not decidable at build time for a published zero
+// artifact on Next or Metro, so the loader still guarantees the island has its
+// styles; on a correct build this never runs.
+function ensureZeroStylesheet() {
+  const links = document.querySelectorAll('link[rel="stylesheet"]')
+  for (let index = 0; index < links.length; index++) {
+    const href = links[index].getAttribute('href') || ''
+    if (href === CSS_HREF || href.split('?')[0].endsWith(CSS_HREF)) return
+  }
+  console.error(
+    '[tamagui zero-runtime] the page did not link the generated CSS artifact ' +
+      CSS_HREF +
+      ', so island "' +
+      ISLAND_ID +
+      '" (' +
+      INTEGRATION +
+      ') is loading it at runtime. On a correct build this never happens: the ' +
+      'artifact is generated by the build and must be linked by the document ' +
+      'that mounts the island. Fix the document, not this recovery.'
+  )
+  const link = document.createElement('link')
+  link.rel = 'stylesheet'
+  link.href = CSS_HREF
+  link.setAttribute('data-tamagui-zero-css', '1')
+  document.head.appendChild(link)
+}
+
+let pending = null
+
+function loadIsland() {
+  const scope = sharedRuntime()
+  const registered = scope[${JSON.stringify(ISLAND_REGISTRY_KEY)}][ISLAND_ID]
+  if (registered) return Promise.resolve(registered)
+  if (!pending) {
+    pending = new Promise((resolve, reject) => {
+      ensureZeroStylesheet()
+      const script = document.createElement('script')
+      script.src = ISLAND_SRC
+      script.async = true
+      script.onload = () => {
+        const mod = scope[${JSON.stringify(ISLAND_REGISTRY_KEY)}][ISLAND_ID]
+        if (mod) resolve(mod)
+        else reject(new Error('tamagui island ' + ISLAND_ID + ' did not register'))
+      }
+      script.onerror = () => reject(new Error('tamagui island ' + ISLAND_ID + ' failed to load ' + ISLAND_SRC))
+      document.head.appendChild(script)
+    })
+  }
+  return pending
+}
+
+export default function TamaguiIsland(props) {
+  const bridgeId = props['data-tamagui-bridge'] || 'root'
+  const [Loaded, setLoaded] = React.useState(null)
+
+  React.useEffect(() => {
+    let cancelled = false
+    loadIsland().then((mod) => {
+      if (!cancelled) setLoaded(() => mod.Island)
+    })
+    return () => {
+      cancelled = true
+    }
+  }, [])
+
+  if (!Loaded) {
+    return React.createElement('div', {
+      'data-tamagui-island': ISLAND_ID,
+      'data-tamagui-bridge': bridgeId,
+    })
+  }
+
+  const forwarded = {}
+  for (const key in props) forwarded[key] = props[key]
+  forwarded['data-tamagui-island'] = ISLAND_ID
+  return React.createElement(Loaded, forwarded)
+}
+`;
+}
+function generateIslandEntrySource(input) {
+	const entry = input.island.entry;
+	return `// generated by @tamagui/static zero-runtime. do not edit.
+import * as React from 'react'
+import { TamaguiProvider, Theme } from 'tamagui'
+import { createThemeUpdateState } from '@tamagui/web/theme-update'
+import config from ${JSON.stringify(importPath(entry, input.configPath))}
+import IslandRoot from ${JSON.stringify(importPath(entry, input.island.module))}
+
+export function Island(props) {
+  const bridge = props.__tamaguiBridge
+  const inner = {}
+  for (const key in props) {
+    if (key !== '__tamaguiBridge') inner[key] = props[key]
+  }
+  let node = React.createElement(IslandRoot, inner)
+  const layers = (bridge && bridge.layers) || []
+  for (let index = layers.length - 1; index >= 0; index--) {
+    node = React.createElement(
+      Theme,
+      {
+        _themeUpdate: createThemeUpdateState(
+          layers[index].inlineValues,
+          layers[index].inlineClassName
+        ),
+        forceClassName: true,
+      },
+      node
+    )
+  }
+  // isSubtreeRoot: the island shares a document with a zero page that already
+  // has its own compiled theme spans, so its provider must not write a theme
+  // class onto html or body and must carry its own theme on its own node.
+  return React.createElement(
+    TamaguiProvider,
+    {
+      config,
+      defaultTheme: (bridge && bridge.name) || 'light',
+      disableInjectCSS: true,
+      isSubtreeRoot: true,
+    },
+    node
+  )
+}
+
+const scope = globalThis
+if (!scope[${JSON.stringify(ISLAND_REGISTRY_KEY)}]) scope[${JSON.stringify(ISLAND_REGISTRY_KEY)}] = {}
+scope[${JSON.stringify(ISLAND_REGISTRY_KEY)}][${JSON.stringify(input.island.id)}] = { Island }
+`;
+}
+function writeIslandModules(input) {
+	writeIfChanged(input.island.loader, generateIslandLoaderSource(input));
+	writeIfChanged(input.island.entry, generateIslandEntrySource(input));
+}
+const ISLAND_EXTERNAL_GLOBAL_PATHS = {
+	react: [ISLAND_RUNTIME_KEY, "react"],
+	"react-dom": [ISLAND_RUNTIME_KEY, "reactDom"],
+	"react/jsx-runtime": [ISLAND_RUNTIME_KEY, "jsxRuntime"]
+};
+const ISLAND_EXTERNAL_GLOBALS = Object.fromEntries(Object.entries(ISLAND_EXTERNAL_GLOBAL_PATHS).map(([name, segments]) => [name, `globalThis.${segments.join(".")}`]));
+function mergeIslandBridges(target, incoming) {
+	for (const [islandId, bridges] of incoming) {
+		const list = target.get(islandId) ?? [];
+		for (const bridge of bridges) {
+			const index = list.findIndex((existing) => existing.id === bridge.id);
+			if (index >= 0) list[index] = bridge;
+			else list.push(bridge);
+		}
+		list.sort((left, right) => left.id < right.id ? -1 : left.id > right.id ? 1 : 0);
+		target.set(islandId, list);
+	}
+}