@tamagui/style-grammar 0.0.0-bootstrap.0 → 3.0.0-beta.643.1

package/dist/cjs/toolingDiagnostics.cjs

@@ -0,0 +1,459 @@
+
+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 toolingDiagnostics_exports = {};
+__export(toolingDiagnostics_exports, {
+	canonicalizeStyleValue: () => canonicalizeStyleValue,
+	completeStyleValue: () => completeStyleValue,
+	completeStyleValueAtCursor: () => completeStyleValueAtCursor,
+	createCandidatePropertyVocabulary: () => createCandidatePropertyVocabulary,
+	createGrammarConfigViewFromSerializedConfig: () => createGrammarConfigViewFromSerializedConfig,
+	createStylePropSet: () => createStylePropSet,
+	diagnoseStyleValue: () => diagnoseStyleValue,
+	diagnoseStyleValueProgram: () => diagnoseStyleValueProgram,
+	modifierChainBefore: () => modifierChainBefore,
+	referenceKindFor: () => referenceKindFor
+});
+module.exports = __toCommonJS(toolingDiagnostics_exports);
+var import_candidateTarget = require("./candidateTarget.cjs");
+var import_config = require("./config.cjs");
+var import_geometricShorthand = require("./geometricShorthand.cjs");
+var import_mergeFlatValues = require("./mergeFlatValues.cjs");
+var import_payloadShape = require("./payloadShape.cjs");
+var import_programEligibility = require("./programEligibility.cjs");
+var import_resolvePayload = require("./resolvePayload.cjs");
+var import_registry = require("./registry.cjs");
+var import_valueParser = require("./valueParser.cjs");
+var import_v6ThemeNames = require("./v6ThemeNames.cjs");
+function canonicalizeStyleValue(input, registry) {
+	const parsed = (0, import_valueParser.parseValue)(input, registry);
+	if (!parsed.ok) return parsed;
+	return {
+		ok: true,
+		value: (0, import_mergeFlatValues.formatParsedValue)(parsed.value),
+		parsed: parsed.value
+	};
+}
+function forEachName(names, visit) {
+	if (!names) return;
+	if (Array.isArray(names)) {
+		for (const name of names) visit(name);
+		return;
+	}
+	if (names instanceof Set) {
+		for (const name of names) visit(name);
+		return;
+	}
+	for (const name in names) visit(name);
+}
+function createCandidatePropertyVocabulary(config) {
+	const byName = /* @__PURE__ */ new Map();
+	const entriesByCategory = /* @__PURE__ */ new Map();
+	for (const entry of import_registry.grammarEntries) {
+		if (!entry.tokenCategory) continue;
+		const contributions = entriesByCategory.get(entry.tokenCategory) || [];
+		contributions.push({
+			property: entry.prop,
+			tokenCategory: entry.tokenCategory
+		});
+		entriesByCategory.set(entry.tokenCategory, contributions);
+	}
+	for (const [category, contributions] of entriesByCategory) {
+		forEachName(config.tokenNames?.[category], (name) => {
+			const existing = byName.get(name) || [];
+			for (const contribution of contributions) {
+				if (!existing.some((item) => item.property === contribution.property)) {
+					existing.push(contribution);
+				}
+			}
+			byName.set(name, existing);
+		});
+	}
+	return byName;
+}
+function createGrammarConfigViewFromSerializedConfig(config, metadata) {
+	const isVersioned = typeof metadata === "object" && metadata !== null && metadata.themeFields === "values-only";
+	if (metadata !== void 0 && !isVersioned) {
+		throw new Error("@tamagui/style-grammar: unsupported serialized config themeFields format");
+	}
+	const themes = {};
+	for (const themeName in config.themes) {
+		const serializedTheme = config.themes[themeName];
+		if (!serializedTheme || typeof serializedTheme !== "object") continue;
+		const runtimeTheme = {};
+		for (const key in serializedTheme) {
+			if (isVersioned || key !== "id") {
+				runtimeTheme[key] = serializedTheme[key];
+			}
+		}
+		themes[themeName] = runtimeTheme;
+	}
+	return (0, import_config.createGrammarConfigView)({
+		shorthands: config.shorthands,
+		media: config.media,
+		themes,
+		tokensParsed: config.tokens,
+		fontsParsed: config.fonts
+	});
+}
+const removedThemeNames = new Set(import_v6ThemeNames.v6RemovedThemeNames);
+const grammarProperties = new Set(import_registry.grammarEntries.map((entry) => entry.prop));
+const categoryReferenceKind = {
+	color: "color",
+	space: "length",
+	size: "length",
+	radius: "length",
+	zIndex: "number",
+	fontFamily: "other",
+	fontSize: "length",
+	fontWeight: "number",
+	lineHeight: "length",
+	letterSpacing: "length"
+};
+function referenceKindFor(contributions, targetProperty) {
+	let fallback;
+	for (const contribution of contributions) {
+		const kind = contribution.tokenCategory ? categoryReferenceKind[contribution.tokenCategory] : "other";
+		if (contribution.property === targetProperty) return kind;
+		if (fallback !== "color") fallback = kind;
+	}
+	return fallback ?? "other";
+}
+function parseErrorSpan(input, error) {
+	const length = input.length;
+	if (error.code === "unregistered-modifier" && error.modifier) {
+		return {
+			start: error.index,
+			end: error.index + error.modifier.length
+		};
+	}
+	if (error.code === "unterminated-string" || error.code === "unterminated-function" || error.code === "unterminated-comment") {
+		return {
+			start: Math.max(0, Math.min(error.index, length - 1)),
+			end: length
+		};
+	}
+	const start = Math.max(0, Math.min(error.index, length - 1));
+	const width = error.code === "stray-comment-close" ? 2 : 1;
+	return {
+		start,
+		end: Math.min(length, start + width)
+	};
+}
+function candidateEndWithSuffix(payload, end) {
+	if (payload.charCodeAt(end) !== 47) return end;
+	let cursor = end + 1;
+	while (cursor < payload.length) {
+		const code = payload.charCodeAt(cursor);
+		if (code === 32 || code === 9 || code === 10 || code === 13 || code === 12) break;
+		if (code === 44 || code === 40 || code === 41) break;
+		cursor++;
+	}
+	return cursor;
+}
+function diagnoseStyleValue(property, input, options) {
+	const { result, spans } = (0, import_valueParser.parseValueWithSourceSpans)(input, options.registry);
+	if (!result.ok) {
+		return result.errors.map((error) => {
+			const span = parseErrorSpan(input, error);
+			return {
+				code: error.code,
+				index: span.start,
+				...span,
+				message: error.message
+			};
+		});
+	}
+	const targetProperty = options.config.shorthands?.[property] || property;
+	const targetIsKnown = grammarProperties.has(targetProperty);
+	const candidates = options.candidates || createCandidatePropertyVocabulary(options.config);
+	const diagnostics = [];
+	const diagnosed = /* @__PURE__ */ new Set();
+	const push = (key, diagnostic) => {
+		if (diagnosed.has(key)) return;
+		diagnosed.add(key);
+		diagnostics.push({
+			index: diagnostic.start,
+			...diagnostic
+		});
+	};
+	const diagnoseSegment = (payload, offset) => {
+		const sightings = [];
+		const resolved = (0, import_resolvePayload.resolvePayload)(payload, {
+			lookup(name) {
+				const contributions2 = candidates.get(name);
+				if (!contributions2) return void 0;
+				return {
+					name,
+					kind: referenceKindFor(contributions2, targetProperty)
+				};
+			},
+			onCandidate(start, end, name, reference) {
+				sightings.push({
+					start,
+					end,
+					name,
+					resolved: reference
+				});
+				if (reference) return;
+				const replacement = import_v6ThemeNames.v6ThemeNameReplacements[name];
+				if (replacement) {
+					push(`v6-theme-name-replaced:${name}`, {
+						code: "v6-theme-name-replaced",
+						start: offset + start,
+						end: offset + end,
+						candidate: name,
+						replacement,
+						message: `"${name}" is not a v6 built-in name; use "${replacement}"`
+					});
+				} else if (removedThemeNames.has(name)) {
+					push(`v6-theme-name-removed:${name}`, {
+						code: "v6-theme-name-removed",
+						start: offset + start,
+						end: offset + end,
+						candidate: name,
+						message: `"${name}" was removed from the v6 built-in theme vocabulary`
+					});
+				}
+			}
+		});
+		if (targetIsKnown) {
+			for (const error of resolved.errors) {
+				const sighting2 = sightings.find((entry) => entry.start === error.index);
+				if (!sighting2?.resolved) continue;
+				push(`${error.code}:${error.name}:${error.opacity}`, {
+					code: error.code,
+					start: offset + error.index,
+					end: offset + candidateEndWithSuffix(payload, sighting2.end),
+					candidate: error.name,
+					message: error.message
+				});
+			}
+		}
+		const candidate = resolved.segments.length === 1 && typeof resolved.segments[0] !== "string" ? resolved.segments[0].name : null;
+		if (candidate === null || !targetIsKnown) return;
+		const contributions = candidates.get(candidate);
+		if (!contributions) return;
+		const target = (0, import_candidateTarget.resolveCandidateTarget)(targetProperty, candidate, contributions);
+		if (target.ok) return;
+		const sighting = sightings.find((entry) => entry.name === candidate && entry.resolved);
+		push(`${target.diagnostic.code}:${candidate}:${targetProperty}`, {
+			...target.diagnostic,
+			start: offset + (sighting?.start ?? 0),
+			end: offset + (sighting?.end ?? payload.length)
+		});
+	};
+	for (const span of spans) {
+		if (span.kind !== "base" && span.kind !== "payload") continue;
+		if (span.start >= span.end) continue;
+		diagnoseSegment(input.slice(span.start, span.end), span.start);
+	}
+	return diagnostics;
+}
+function modifierChainBefore(input, spans, start) {
+	const byEnd = /* @__PURE__ */ new Map();
+	for (const span of spans) {
+		if (span.kind === "modifier") byEnd.set(span.end, span);
+	}
+	const reversed = [];
+	let colon = start - 1;
+	while (colon >= 0 && input.charCodeAt(colon) === 58) {
+		const span = byEnd.get(colon);
+		if (!span) break;
+		reversed.push(input.slice(span.start, span.end));
+		colon = span.start - 1;
+	}
+	reversed.reverse();
+	return reversed;
+}
+function createStylePropSet(config) {
+	const styleProps = /* @__PURE__ */ new Set([...import_registry.grammarEntries.map((entry) => entry.prop), ...Object.keys(import_programEligibility.legacyPartComposite)]);
+	for (const shorthand in config.shorthands) {
+		styleProps.add(shorthand);
+		styleProps.add(config.shorthands[shorthand]);
+	}
+	return styleProps;
+}
+function payloadSpan(input, payload) {
+	const at = input.indexOf(payload);
+	return at === -1 ? {
+		start: 0,
+		end: input.length
+	} : {
+		start: at,
+		end: at + payload.length
+	};
+}
+function diagnoseStyleValueProgram(property, input, options) {
+	const candidates = options.candidates || createCandidatePropertyVocabulary(options.config);
+	const scoped = {
+		...options,
+		candidates
+	};
+	const diagnostics = diagnoseStyleValue(property, input, scoped);
+	if (diagnostics.length > 0) return diagnostics;
+	const parsed = (0, import_valueParser.parseValue)(input, options.registry);
+	if (!parsed.ok) return diagnostics;
+	const targetProperty = options.config.shorthands?.[property] || property;
+	if (parsed.value.clauses.length > 0 && (0, import_programEligibility.programEligibility)(targetProperty) === "legacy-part") {
+		return [{
+			code: "legacy-part-conditional",
+			index: 0,
+			start: 0,
+			end: input.length,
+			property: targetProperty,
+			message: `conditional values are not supported on part prop "${targetProperty}"; move the condition onto \`${import_programEligibility.legacyPartComposite[targetProperty]}\``
+		}];
+	}
+	const results = [];
+	const reported = /* @__PURE__ */ new Set();
+	const geometric = (0, import_geometricShorthand.splitGeometricShorthandValue)(targetProperty, parsed.value);
+	const programs = geometric && geometric.errors.length === 0 ? geometric.entries : [{
+		property: targetProperty,
+		value: parsed.value
+	}];
+	for (const program of programs) {
+		const { base, clauses } = program.value;
+		const payloads = [...base === null ? [] : [base], ...clauses.map((clause) => clause.payload)];
+		for (const payload of payloads) {
+			for (const diagnostic of diagnoseStyleValueProgramSlot(program.property, payload, scoped)) {
+				const key = `${diagnostic.code}:${diagnostic.candidate}:${program.property}`;
+				if (reported.has(key)) continue;
+				reported.add(key);
+				const span = payloadSpan(input, payload);
+				results.push({
+					...diagnostic,
+					index: span.start,
+					...span
+				});
+			}
+		}
+		if (base !== null) {
+			pushShapeDiagnostic(results, reported, input, program.property, base, true);
+		}
+		for (const clause of clauses) {
+			pushShapeDiagnostic(results, reported, input, program.property, clause.payload, base !== null);
+		}
+	}
+	return results;
+}
+function diagnoseStyleValueProgramSlot(property, payload, options) {
+	const slotDiagnostics = diagnoseStyleValue(property, payload, options);
+	return slotDiagnostics.filter((diagnostic) => diagnostic.code === "candidate-property-mismatch");
+}
+function pushShapeDiagnostic(results, reported, input, property, payload, hasBase) {
+	const diagnostic = (0, import_payloadShape.validatePayloadShape)(property, payload, hasBase);
+	if (!diagnostic) return;
+	const key = `${diagnostic.code}:${diagnostic.payload}:${property}`;
+	if (reported.has(key)) return;
+	reported.add(key);
+	const span = payloadSpan(input, payload);
+	results.push({
+		code: diagnostic.code,
+		index: span.start,
+		...span,
+		property,
+		message: diagnostic.message
+	});
+}
+function completeStyleValue(property, options) {
+	const candidates = options.candidates || createCandidatePropertyVocabulary(options.config);
+	const targetProperty = options.config.shorthands?.[property] || property;
+	if (!grammarProperties.has(targetProperty)) return [];
+	const byValue = /* @__PURE__ */ new Map();
+	for (const [value, contributions] of candidates) {
+		if ((0, import_candidateTarget.resolveCandidateTarget)(targetProperty, value, contributions).ok) {
+			byValue.set(value, "configured");
+		}
+	}
+	const standalone = import_registry.standaloneValueProps[targetProperty];
+	if (standalone) {
+		for (const value in standalone) {
+			if (!byValue.has(value)) byValue.set(value, "keyword");
+		}
+	}
+	if (targetProperty === "fontWeight") {
+		for (const value in import_registry.fontWeightNames) {
+			if (!byValue.has(value)) byValue.set(value, "keyword");
+		}
+	}
+	const completions = [];
+	for (const [value, kind] of byValue) {
+		if (diagnoseStyleValue(property, value, {
+			...options,
+			candidates
+		}).length === 0) {
+			completions.push({
+				value,
+				kind
+			});
+		}
+	}
+	completions.sort((a, b) => a.value < b.value ? -1 : a.value > b.value ? 1 : 0);
+	return completions;
+}
+function completeStyleValueAtCursor(property, input, cursor, options) {
+	if (cursor < 0 || cursor > input.length) return null;
+	const parsed = (0, import_valueParser.parseValueWithSourceSpans)(input, options.registry);
+	const active = parsed.spans.find((span) => cursor >= span.start && cursor <= span.end && span.kind === "modifier") ?? parsed.spans.find((span) => cursor >= span.start && cursor <= span.end && span.kind === "word" && span.start > 0 && parsed.result.ok && parsed.spans.some((segment) => (segment.kind === "base" || segment.kind === "payload") && segment.start < span.start && segment.end >= span.end)) ?? parsed.spans.find((span) => cursor >= span.start && cursor <= span.end && span.kind !== "modifier" && span.kind !== "word");
+	if (active?.kind === "modifier" || active?.kind === "word") {
+		if (!parsed.result.ok && parsed.result.errors.some((error) => error.code !== "unregistered-modifier" && error.code !== "empty-modifier" && error.code !== "empty-payload")) {
+			return null;
+		}
+		return {
+			replaceStart: active.start,
+			replaceLength: active.end - active.start,
+			completions: completeModifiers(options, input.charCodeAt(active.end) !== 58, active.kind === "modifier" ? modifierChainBefore(input, parsed.spans, active.start) : [])
+		};
+	}
+	if (active) {
+		if (!parsed.result.ok && parsed.result.errors.some((error) => error.code !== "empty-payload")) {
+			return null;
+		}
+		return {
+			replaceStart: active.start,
+			replaceLength: active.end - active.start,
+			completions: active.kind === "payload" && input.charCodeAt(active.start - 1) === 58 ? [...completeModifiers(options, true, modifierChainBefore(input, parsed.spans, active.start)), ...completeStyleValue(property, options)] : completeStyleValue(property, options)
+		};
+	}
+	if (parsed.result.ok && cursor === input.length) {
+		return {
+			replaceStart: cursor,
+			replaceLength: 0,
+			completions: completeModifiers(options, true, [])
+		};
+	}
+	return null;
+}
+function completeModifiers(options, appendColon, modifiers) {
+	const names = options.registry.next?.(modifiers);
+	if (!names) return [];
+	const completions = [];
+	for (const name of names) {
+		completions.push({
+			value: name,
+			kind: "modifier",
+			insertText: appendColon ? `${name}:` : name
+		});
+	}
+	completions.sort((a, b) => a.value < b.value ? -1 : a.value > b.value ? 1 : 0);
+	return completions;
+}