@tamagui/compiler-core 0.0.0-bootstrap.0 → 3.0.0-beta.1093.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Nate Wienert
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1 +1,57 @@
-# @tamagui/compiler-core
+# `@tamagui/compiler-core`
+
+`CompilerSession` is Tamagui's bundler-neutral compiler API. It owns parsing,
+the module graph, invalidation, lowering, and source-map-aware output. The host
+owns resolution and loading.
+
+```ts
+import {
+  CompilerSession,
+  resolvedModuleId,
+  type CompilerAdapter,
+  type HostModuleInput,
+} from '@tamagui/compiler-core'
+
+const session = new CompilerSession()
+const entry: HostModuleInput = {
+  id: resolvedModuleId('/app/Button.tsx'),
+  source: buttonSource,
+  imports: [
+    {
+      specifier: './tokens',
+      resolvedId: resolvedModuleId('/app/tokens.ts'),
+    },
+  ],
+}
+
+const adapter: CompilerAdapter = {
+  target: 'web',
+  projectGeneration: configHash,
+  host: createYourLoweringHost(),
+  async load(id) {
+    return modules.get(id) ?? null
+  },
+}
+
+const result = await session.compile({ module: entry, adapter })
+```
+
+Every `HostModuleInput` must contain a canonical id and every import must
+already be resolved by the host. Mark package or runtime boundaries with
+`external: true`. Call `update()` or `remove()` on watch changes and use the
+returned ids to invalidate the host's module graph. Change
+`projectGeneration` whenever Tamagui config or component metadata changes.
+
+Adapters should pass the output source map back to their bundler and watch the
+dependencies they loaded. Native adapters must reject CSS output rather than
+silently dropping it.
+
+The maintained adapters are:
+
+- `@tamagui/vite-plugin` for Vite web and One's iOS/Android Rolldown pipeline
+  through its Vite config provider API
+- `@tamagui/metro-plugin` for Metro's main-process graph and worker cache
+- `tamagui build` for explicit precompilation, including Next.js Turbopack
+
+The legacy `@tamagui/next-plugin` and `tamagui-loader` packages only support
+webpack and are outside the v3 compiler path.

package/dist/cjs/ast.cjs

@@ -0,0 +1,108 @@
+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 ast_exports = {};
+__export(ast_exports, {
+	childNode: () => childNode,
+	childNodes: () => childNodes,
+	findAstNode: () => findAstNode,
+	identifierName: () => identifierName,
+	isAstNode: () => isAstNode,
+	literalValue: () => literalValue,
+	unwrapExpression: () => unwrapExpression,
+	walkAst: () => walkAst
+});
+module.exports = __toCommonJS(ast_exports);
+const ignoredKeys = /* @__PURE__ */ new Set([
+	"loc",
+	"range",
+	"parent",
+	"comments",
+	"tokens"
+]);
+function isAstNode(value) {
+	return typeof value === "object" && value !== null && typeof value.type === "string" && typeof value.start === "number" && typeof value.end === "number";
+}
+function walkAst(node, visitor, parent = null, key = null) {
+	visitor(node, parent, key);
+	for (const childKey of Object.keys(node)) {
+		if (ignoredKeys.has(childKey)) continue;
+		const value = node[childKey];
+		if (isAstNode(value)) {
+			walkAst(value, visitor, node, childKey);
+		} else if (Array.isArray(value)) {
+			for (const child of value) {
+				if (isAstNode(child)) {
+					walkAst(child, visitor, node, childKey);
+				}
+			}
+		}
+	}
+}
+function findAstNode(root, predicate, span) {
+	function visit(node, parent, key) {
+		if (span && (node.start > span.start || node.end < span.end)) return null;
+		if (predicate(node, parent, key)) return node;
+		for (const childKey of Object.keys(node)) {
+			if (ignoredKeys.has(childKey)) continue;
+			const value = node[childKey];
+			if (isAstNode(value)) {
+				const found = visit(value, node, childKey);
+				if (found) return found;
+			} else if (Array.isArray(value)) {
+				for (const child of value) {
+					if (!isAstNode(child)) continue;
+					const found = visit(child, node, childKey);
+					if (found) return found;
+				}
+			}
+		}
+		return null;
+	}
+	return visit(root, null, null);
+}
+function childNode(node, key) {
+	const value = node[key];
+	return isAstNode(value) ? value : null;
+}
+function childNodes(node, key) {
+	const value = node[key];
+	return Array.isArray(value) ? value.filter(isAstNode) : [];
+}
+function identifierName(node) {
+	if (!node || node.type !== "Identifier" && node.type !== "JSXIdentifier") return null;
+	return typeof node.name === "string" ? node.name : null;
+}
+function literalValue(node) {
+	if (!node) return void 0;
+	if (node.type === "Literal" || node.type.endsWith("Literal")) {
+		return node.value;
+	}
+	return void 0;
+}
+function unwrapExpression(node) {
+	let current = node;
+	while (current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSNonNullExpression" || current.type === "ParenthesizedExpression") {
+		const expression = childNode(current, "expression");
+		if (!expression) break;
+		current = expression;
+	}
+	return current;
+}

package/dist/cjs/contracts.cjs

@@ -0,0 +1,61 @@
+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 contracts_exports = {};
+__export(contracts_exports, {
+	expressionReference: () => expressionReference,
+	resolutionKey: () => resolutionKey,
+	resolveFromHost: () => resolveFromHost,
+	resolvedModuleId: () => resolvedModuleId,
+	spanOf: () => spanOf,
+	textOfSpan: () => textOfSpan
+});
+module.exports = __toCommonJS(contracts_exports);
+function resolutionKey(importer, specifier) {
+	return `${importer}\0${specifier}`;
+}
+function resolveFromHost(resolutions, specifier, importer) {
+	return resolutions.get(resolutionKey(importer, specifier)) ?? null;
+}
+function resolvedModuleId(id) {
+	const isAbsolute = id.startsWith("/") || id.startsWith("\\") || id.startsWith("\0") || /^[A-Za-z]:[\\/]/.test(id) || /^[A-Za-z][A-Za-z\d+.-]*:\/\//.test(id);
+	if (!isAbsolute) {
+		throw new Error(`Host module id must be canonical and already resolved: ${id}`);
+	}
+	return id;
+}
+function expressionReference(id, node) {
+	return {
+		kind: "expression",
+		id,
+		start: node.start,
+		end: node.end
+	};
+}
+function spanOf(id, node) {
+	return {
+		id,
+		start: node.start,
+		end: node.end
+	};
+}
+function textOfSpan(source, span) {
+	return source.slice(span.start, span.end);
+}

package/dist/cjs/diagnostics.cjs

@@ -0,0 +1,68 @@
+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 diagnostics_exports = {};
+__export(diagnostics_exports, {
+	linkedBailout: () => linkedBailout,
+	localBailout: () => localBailout,
+	zeroRuleForBailout: () => zeroRuleForBailout
+});
+module.exports = __toCommonJS(diagnostics_exports);
+const ZERO_RULE_BY_CODE = {
+	"local/invalid-element-call": 2,
+	"local/unsupported-element-name": 2,
+	"local/unsupported-prop-key": 3,
+	"local/unsupported-child": 3,
+	"local/unsupported-expression": 3,
+	"local/unsupported-styled-definition": 3,
+	"local/dynamic-style-value": 3,
+	"local/unsafe-style-spread": 1,
+	"local/unsupported-target": 6,
+	"local/style-resolution-failed": 3,
+	"local/overlapping-edit": 6,
+	"local/non-object-spread": 1,
+	"local/static-evaluation-cycle": 3,
+	"local/parse-error": 3,
+	"linked/unresolved-component-binding": 2,
+	"linked/unresolved-binding": 2,
+	"linked/missing-initializer": 3,
+	"linked/unresolved-import": 2,
+	"linked/unresolved-component-config": 2
+};
+function zeroRuleForBailout(reason) {
+	return reason.zeroRule ?? ZERO_RULE_BY_CODE[reason.code];
+}
+function localBailout(code, span, message) {
+	return {
+		code,
+		kind: "local",
+		message,
+		span
+	};
+}
+function linkedBailout(code, span, message, dependencyId) {
+	return {
+		code,
+		kind: "linked",
+		message,
+		span,
+		dependencyId
+	};
+}