@tamagui/static 2.7.7 → 3.0.0-beta.643.1

package/dist/cjs/zero/islands.cjs

@@ -0,0 +1,232 @@
+
+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 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,
+      {
+        inlineValues: layers[index].inlineValues,
+        inlineClassName: 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);
+	}
+}

package/dist/cjs/zero/options.cjs

@@ -0,0 +1,163 @@
+
+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 options_exports = {};
+__export(options_exports, {
+	ZERO_INTEGRATION_SUPPORT: () => ZERO_INTEGRATION_SUPPORT,
+	ZERO_OUT_DIRNAME: () => ZERO_OUT_DIRNAME,
+	assertZeroConfigDrivers: () => assertZeroConfigDrivers,
+	assertZeroIntegrationSupport: () => assertZeroIntegrationSupport,
+	islandIdFor: () => islandIdFor,
+	resolveZeroRuntime: () => resolveZeroRuntime,
+	resolveZeroRuntimeSync: () => resolveZeroRuntimeSync
+});
+module.exports = __toCommonJS(options_exports);
+var import_compiler_core = require("@tamagui/compiler-core");
+var import_fast_glob = __toESM(require("fast-glob"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+const ZERO_OUT_DIRNAME = ".tamagui/zero";
+function islandIdFor(moduleId) {
+	return import_node_path.default.basename(moduleId).replace(/\.[jt]sx?$/, "");
+}
+async function resolveZeroRuntime(options, root) {
+	const early = resolveZeroRuntimeEarly(options, root);
+	if (early.done) return early.resolved;
+	return finishZeroRuntime(options, root, early.islandGlobs, early.islandGlobs.length ? await (0, import_fast_glob.default)(early.islandGlobs, {
+		cwd: root,
+		absolute: true,
+		dot: false
+	}) : []);
+}
+function resolveZeroRuntimeSync(options, root) {
+	const early = resolveZeroRuntimeEarly(options, root);
+	if (early.done) return early.resolved;
+	return finishZeroRuntime(options, root, early.islandGlobs, early.islandGlobs.length ? import_fast_glob.default.sync(early.islandGlobs, {
+		cwd: root,
+		absolute: true,
+		dot: false
+	}) : []);
+}
+function resolveZeroRuntimeEarly(options, root) {
+	const requested = options.experimental?.zeroRuntime;
+	const outDir = import_node_path.default.join(root, ZERO_OUT_DIRNAME);
+	const off = {
+		mode: "off",
+		root,
+		islandGlobs: [],
+		islands: [],
+		outDir,
+		cssPath: ""
+	};
+	if (!requested) return {
+		done: true,
+		resolved: off
+	};
+	if (options.platform === "native" && requested === "report") {
+		return {
+			done: true,
+			resolved: {
+				...off,
+				mode: "report"
+			}
+		};
+	}
+	if (options.platform === "native") {
+		throw new Error(`[tamagui zero-runtime] experimental.zeroRuntime is web only. A native build always receives TAMAGUI_RUNTIME="full".`);
+	}
+	if (requested !== "report" && !options.outputCSS) {
+		throw new Error(`[tamagui zero-runtime] experimental.zeroRuntime requires outputCSS. The bundler owns one generated CSS artifact and derives TAMAGUI_DID_OUTPUT_CSS from it.`);
+	}
+	if (requested !== "report" && process.env.TAMAGUI_DOES_SSR_CSS === "mutates-themes") {
+		throw new Error(`[tamagui zero-runtime] Rule 4: TAMAGUI_DOES_SSR_CSS="mutates-themes" declares runtime theme mutation. Zero-runtime themes are build-time data. Remove runtime mutation or move that surface to a full-runtime island.`);
+	}
+	return {
+		done: false,
+		islandGlobs: requested === true || requested === "report" ? [] : requested.islands
+	};
+}
+function finishZeroRuntime(options, root, islandGlobs, matches) {
+	const outDir = import_node_path.default.join(root, ZERO_OUT_DIRNAME);
+	const outputCSS = options.outputCSS ?? "";
+	const islands = [...new Set(matches.map((match) => import_node_path.default.normalize(match)))].sort().map((module2) => {
+		const id = islandIdFor(module2);
+		return {
+			id,
+			module: module2,
+			loader: import_node_path.default.join(outDir, `${id}.loader.js`),
+			entry: import_node_path.default.join(outDir, `${id}.entry.js`)
+		};
+	});
+	const seen = /* @__PURE__ */ new Set();
+	for (const island of islands) {
+		if (seen.has(island.id)) {
+			throw new Error(`[tamagui zero-runtime] two declared islands share the basename "${island.id}". Island ids are their module basename because that is also the generated loader's filename.`);
+		}
+		seen.add(island.id);
+	}
+	if (islandGlobs.length && islands.length === 0) {
+		throw new Error(`[tamagui zero-runtime] experimental.zeroRuntime.islands matched no module for ${JSON.stringify(islandGlobs)}`);
+	}
+	return {
+		mode: options.experimental?.zeroRuntime === "report" ? "report" : "enforce",
+		root,
+		islandGlobs,
+		islands,
+		outDir,
+		cssPath: !outputCSS ? "" : import_node_path.default.isAbsolute(outputCSS) ? outputCSS : import_node_path.default.resolve(root, outputCSS)
+	};
+}
+function assertZeroConfigDrivers(config) {
+	const drivers = config.animationDrivers ? Object.entries(config.animationDrivers) : [["default", config.animations]];
+	for (const [name, driver] of drivers) {
+		if (!driver || driver.outputStyle === "css") continue;
+		throw new Error((0, import_compiler_core.zeroConfigDriverMessage)(name, driver.outputStyle));
+	}
+}
+const ZERO_INTEGRATION_SUPPORT = {
+	vite: {
+		base: true,
+		islands: true
+	},
+	"next-webpack": {
+		base: true,
+		islands: true
+	},
+	"metro-web": {
+		base: true,
+		islands: true
+	}
+};
+function assertZeroIntegrationSupport(integration, resolved) {
+	if (resolved.mode !== "enforce") return;
+	const support = ZERO_INTEGRATION_SUPPORT[integration];
+	if (!support.base) {
+		throw new Error(`[tamagui zero-runtime] ${integration} has not qualified for zero-runtime output in this version. Use zeroRuntime: "report" or choose a qualified integration.`);
+	}
+	if (resolved.islands.length && !support.islands) {
+		throw new Error(`[tamagui zero-runtime] ${integration} does not support experimental.zeroRuntime islands in this version. Use zeroRuntime: true without islands or choose an integration with island support.`);
+	}
+}

package/dist/cjs/zero/ownership.cjs

@@ -0,0 +1,79 @@
+
+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 ownership_exports = {};
+__export(ownership_exports, {
+	checkGlobalCSSArtifact: () => checkGlobalCSSArtifact,
+	declaresRuntimeThemeMutation: () => declaresRuntimeThemeMutation,
+	hashCSS: () => hashCSS,
+	resolveGlobalCSSOwnership: () => resolveGlobalCSSOwnership
+});
+module.exports = __toCommonJS(ownership_exports);
+var import_node_crypto = require("node:crypto");
+var import_node_fs = require("node:fs");
+var import_node_path = __toESM(require("node:path"), 1);
+var import_options = require("./options.cjs");
+const hashCSS = (css) => (0, import_node_crypto.createHash)("sha256").update(css).digest("hex").slice(0, 16);
+const normalize = (value) => value.split(/[?#]/, 1)[0].replace(/\\/g, "/");
+const declaresRuntimeThemeMutation = () => process.env.TAMAGUI_DOES_SSR_CSS === "mutates-themes";
+function resolveGlobalCSSOwnership(options, root) {
+	if (options.disable) return null;
+	if (options.platform === "native") return null;
+	if (!options.outputCSS) return null;
+	if (declaresRuntimeThemeMutation()) return null;
+	if ((0, import_options.resolveZeroRuntimeSync)(options, root).mode === "enforce") return null;
+	return { cssPath: import_node_path.default.isAbsolute(options.outputCSS) ? options.outputCSS : import_node_path.default.resolve(root, options.outputCSS) };
+}
+function checkGlobalCSSArtifact(input) {
+	const { cssPath, expectedCSS } = input;
+	let onDisk;
+	try {
+		onDisk = (0, import_node_fs.readFileSync)(cssPath, "utf8");
+	} catch {
+		return {
+			kind: "missing",
+			cssPath,
+			message: `[tamagui] the generated CSS artifact ${cssPath} does not exist, so this build cannot claim TAMAGUI_DID_OUTPUT_CSS. The design-system, :root, font and theme rules would be stripped from JavaScript and put nowhere.`
+		};
+	}
+	if (onDisk !== expectedCSS) {
+		return {
+			kind: "stale",
+			cssPath,
+			message: `[tamagui] the generated CSS artifact ${cssPath} is stale: it hashes ${hashCSS(onDisk)} but this build's config generates ${hashCSS(expectedCSS)}. Deriving TAMAGUI_DID_OUTPUT_CSS from it would ship rules that do not match the build.`
+		};
+	}
+	const wanted = normalize(cssPath);
+	for (const id of input.loadedModuleIds) {
+		if (normalize(id) === wanted) return null;
+	}
+	return {
+		kind: "unimported",
+		cssPath,
+		message: `[tamagui] the generated CSS artifact ${cssPath} exists but the entry graph never loads it. ${input.importHint}`
+	};
+}