boss-css 0.0.1 → 0.0.2

package/dist/native/browser.mjs

@@ -0,0 +1,77 @@
+import { resolveRuntimeToken } from "../use/token/runtime-only.mjs";
+
+//#region src/native/browser.ts
+const ignoredProps = new Set([
+	"ref",
+	"children",
+	"as",
+	"className",
+	"css",
+	"child",
+	"at",
+	"pseudo"
+]);
+const isNumericValue = (value) => {
+	if (typeof value === "number") return true;
+	if (typeof value !== "string") return false;
+	return /^-?\d+(?:\.\d+)?$/.test(value);
+};
+const normalizeValue = (value) => {
+	if (Array.isArray(value)) return value.map((entry) => normalizeValue(entry));
+	if (isNumericValue(value)) return typeof value === "string" ? Number(value) : value;
+	return value;
+};
+const getStyleProps = (api) => {
+	if (!api.nativeStyleProps) return /* @__PURE__ */ new Set();
+	api.nativeStylePropSet ??= new Set(api.nativeStyleProps);
+	return api.nativeStylePropSet;
+};
+const name = "native";
+const onBrowserObjectStart = (api, { input, output = {} }) => {
+	const styleProps = getStyleProps(api);
+	const bossStyle = {};
+	let hasBossStyle = false;
+	for (const prop in input) {
+		if (ignoredProps.has(prop)) {
+			delete input[prop];
+			continue;
+		}
+		if (prop === "style") {
+			output.style = input[prop];
+			delete input[prop];
+			continue;
+		}
+		if (!styleProps.has(prop)) {
+			output[prop] = input[prop];
+			delete input[prop];
+			continue;
+		}
+		let value = input[prop];
+		if (typeof value === "function") value = value();
+		const token = resolveRuntimeToken(api, prop, value);
+		if (token) value = token.value;
+		bossStyle[prop] = normalizeValue(value);
+		hasBossStyle = true;
+		delete input[prop];
+	}
+	if (!hasBossStyle) return;
+	if (!output.style) {
+		output.style = bossStyle;
+		return;
+	}
+	if (Array.isArray(output.style)) {
+		output.style = [...output.style, bossStyle];
+		return;
+	}
+	if (typeof output.style === "object") {
+		output.style = {
+			...output.style,
+			...bossStyle
+		};
+		return;
+	}
+	output.style = [output.style, bossStyle];
+};
+
+//#endregion
+export { name, onBrowserObjectStart };

package/dist/native/server.cjs

@@ -0,0 +1,180 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_extractCode = require('../parser/jsx/extractCode.cjs');
+const require_extractPrepared = require('../parser/jsx/extractPrepared.cjs');
+const require_extractProps = require('../parser/jsx/extractProps.cjs');
+const require_styleTypes = require('./styleTypes.cjs');
+let ts_deepmerge = require("ts-deepmerge");
+
+//#region src/native/server.ts
+const name = "native";
+const settings = new Map([
+	["name", "$$"],
+	["globals", true],
+	["emitRuntime", false]
+]);
+const nativeComponentNames = [
+	"ActivityIndicator",
+	"FlatList",
+	"Image",
+	"Modal",
+	"Pressable",
+	"SafeAreaView",
+	"ScrollView",
+	"SectionList",
+	"Switch",
+	"Text",
+	"TextInput",
+	"TouchableHighlight",
+	"TouchableOpacity",
+	"TouchableWithoutFeedback",
+	"View"
+];
+const defaultTokens = { color: {
+	black: "#000",
+	white: "#fff"
+} };
+let needsRuntime = false;
+const preparedComponents = /* @__PURE__ */ new Map();
+const syncPreparedDts = (api) => {
+	const entries = Array.from(preparedComponents.entries()).sort(([a], [b]) => a.localeCompare(b));
+	const lines = ["interface $$Prepared {"];
+	for (const [name] of entries) {
+		const baseType = "DefaultNativeElement";
+		const getterType = `BaseFn<${baseType}>`;
+		const setterType = `$$PreparedDefinitionForSet<${baseType}>`;
+		lines.push(`    get ${name}(): ${getterType};`);
+		lines.push(`    set ${name}(value: ${setterType});`);
+	}
+	lines.push("}");
+	api.file.native.dts.set("body", "jsx:prepared-interface", lines.join("\n"));
+};
+const onBoot = async (api) => {
+	preparedComponents.clear();
+	needsRuntime = false;
+	const needsRuntimeTest = () => needsRuntime || settings.get("emitRuntime") === true;
+	const proxyVar = api.file.native.import({
+		name: "proxy",
+		from: "boss-css/parser/jsx/native"
+	}, needsRuntimeTest);
+	api.file.native.importAndConfig({
+		name: "onBrowserObjectStart",
+		from: "boss-css/native/browser"
+	}, needsRuntimeTest);
+	settings.get("globals") && api.file.native.set("body", "jsx:globalThis", `globalThis.${settings.get("name")} = ${proxyVar}`, needsRuntimeTest);
+	api.file.native.set("body", "jsx:export-const", `export const ${settings.get("name")} = ${proxyVar}`, needsRuntimeTest);
+	api.file.native.set("foot", "jsx:export-default", `export default ${proxyVar}`, needsRuntimeTest);
+	const tokenCreatorVar = api.file.native.import({
+		name: "create",
+		from: "boss-css/use/token/runtime-only"
+	}, needsRuntimeTest);
+	api.file.native.set("foot", "token:$$.token", `$$.token = ${tokenCreatorVar}()`, needsRuntimeTest);
+	const { props } = await require_styleTypes.loadReactNativeStyleProps();
+	const nativeStyleProps = Array.from(props.keys()).sort();
+	const mergedTokens = (0, ts_deepmerge.merge)(defaultTokens, api.tokens ?? {});
+	api.file.native.config({
+		from: "boss-css/native",
+		config: {
+			nativeStyleProps,
+			tokens: mergedTokens,
+			runtime: { only: true }
+		}
+	}, needsRuntimeTest);
+	api.file.native.dts.set("head", "jsx:runtime", `import type React from 'react'`);
+	api.file.native.dts.set("head", "jsx:native-components", `import type { ${nativeComponentNames.join(", ")} } from 'react-native'`);
+	api.file.native.dts.set("body", "jsx:utils", `type AsProp<C extends React.ElementType> = {
+    as?: C
+}
+type PropsToOmit<C extends React.ElementType, P> = keyof (AsProp<C> & P)
+type PolymorphicComponentProp<C extends React.ElementType, Props = {}> = React.PropsWithChildren<Props & AsProp<C>> &
+    Omit<React.ComponentPropsWithoutRef<C>, PropsToOmit<C, Props>>
+type PolymorphicComponentPropWithRef<C extends React.ElementType, Props = {}> = PolymorphicComponentProp<C, Props> & {
+    ref?: PolymorphicRef<C>
+}
+type PolymorphicRef<C extends React.ElementType> = React.ComponentPropsWithRef<C>['ref']
+
+type DefaultNativeElement = typeof View
+type $$JSXFinalProps<C extends React.ElementType> = PolymorphicComponentPropWithRef<C, $$FinalProps>
+declare const $$PreparedBrand: unique symbol
+type $$PreparedProps<Base extends React.ElementType = DefaultNativeElement, C extends React.ElementType = Base> = Omit<
+    $$JSXFinalProps<C>,
+    'children' | 'ref'
+> &
+    (C extends Base ? { as?: C } : { as: C })
+type $$PreparedDefinition<Base extends React.ElementType = DefaultNativeElement, C extends React.ElementType = Base> =
+    $$PreparedProps<Base, C> & { readonly [typeof $$PreparedBrand]: true }
+type $$PreparedDefinitionForSet<Base extends React.ElementType = DefaultNativeElement> =
+    | $$PreparedDefinition<Base, Base>
+    | {
+          [K in keyof JSX.IntrinsicElements]: $$PreparedDefinition<Base, K> & { as: K }
+      }[keyof JSX.IntrinsicElements]
+type $$NoopFn = {
+    (props: $$PreparedProps<DefaultNativeElement, DefaultNativeElement>): $$PreparedDefinition<DefaultNativeElement, DefaultNativeElement>
+    <C extends React.ElementType>(props: $$PreparedProps<DefaultNativeElement, C> & { as: C }): $$PreparedDefinition<DefaultNativeElement, C>
+    (input: string): string
+}
+type StyleFn = {
+    (...inputs: $$FinalProps[]): BossComponentProps<DefaultNativeElement>
+}
+type CssFn = {
+    (input: TemplateStringsArray, ...exprs: unknown[]): void
+    (input: string | Record<string, unknown>): void
+}
+
+type NativeComponentMap = {
+${nativeComponentNames.map((name) => `    ${name}: typeof ${name};`).join("\n")}
+}
+
+type BaseFn<T extends React.ElementType = DefaultNativeElement> = {
+    <C extends React.ElementType = T, L extends React.LegacyRef>(
+        props: $$JSXFinalProps<C>,
+        contexts?: L,
+    ): L extends React.LegacyRef ? React.ReactNode : $$FinalProps
+}`);
+	syncPreparedDts(api);
+	api.file.native.dts.set("body", "jsx:proxy-start", `type ProxyCustomMembers = {
+`).set("body", "jsx:proxy-utils", `    $: $$NoopFn
+    merge: (...inputs: import('boss-css/merge').MergeInput[]) => import('boss-css/merge').MergeOutput
+    cx: (...inputs: import('boss-css/cx').CxValue[]) => string
+    cv: typeof import('boss-css/cx').cv
+    scv: typeof import('boss-css/cx').scv
+    sv: typeof import('boss-css/cx').sv
+    css: CssFn
+    style: StyleFn
+`).set("body", "jsx:proxy-custom-members", ``).set("body", "jsx:proxy-custom-members-end", `}`).set("body", "jsx:proxy-type", `type Proxy = BaseFn & {
+    [T in keyof NativeComponentMap]: BaseFn<NativeComponentMap[T]>
+} & $$Prepared & ProxyCustomMembers`);
+	api.file.native.dts.set("foot", "jsx:export", `export declare const $$: Proxy`);
+	if (settings.get("globals")) api.file.native.dts.set("foot", "jsx:globals", `declare global {
+    const $$: Proxy
+}`);
+	api.file.native.dts.set("foot", "$$:default-export", `export default $$`);
+	api.file.native.dts.set("body", "native:StylePropsInterfaceStart", `export interface $$NativeStyleProps {`);
+	for (const [name, prop] of props.entries()) {
+		if (prop.description) api.file.native.dts.set("body", `native:${name}:description`, `  /**\n   * ${prop.description}\n   */`);
+		api.file.native.dts.set("body", `native:${name}:declaration`, `  ${name}?: $$PropValues | ${prop.type};\n`);
+	}
+	api.file.native.dts.set("body", "native:StylePropsInterfaceEnd", `}`);
+	api.file.native.dts.replace("body", `$$:FinalProps`, (v) => `${v} & $$NativeStyleProps`);
+	api.file.native.dts.prepend("body", "jsx:proxy-custom-members", `    token: ${JSON.stringify(mergedTokens, null, 4)}\n`);
+};
+const onParse = async (api, input) => {
+	const { content } = input;
+	const results = await require_extractProps.extractPropTrees(require_extractCode.extractCode(content));
+	needsRuntime ||= !!Object.keys(results).length;
+	const prepared = require_extractPrepared.extractPreparedComponents(content, input.path || input.file);
+	let preparedDirty = false;
+	for (const entry of prepared) {
+		const existing = preparedComponents.get(entry.name);
+		if (!existing || existing.asTag !== entry.asTag || existing.asDynamic !== entry.asDynamic) {
+			preparedComponents.set(entry.name, entry);
+			preparedDirty = true;
+		}
+	}
+	if (preparedDirty) syncPreparedDts(api);
+};
+
+//#endregion
+exports.name = name;
+exports.onBoot = onBoot;
+exports.onParse = onParse;
+exports.settings = settings;

package/dist/native/server.mjs

@@ -0,0 +1,176 @@
+import { extractCode } from "../parser/jsx/extractCode.mjs";
+import { extractPreparedComponents } from "../parser/jsx/extractPrepared.mjs";
+import { extractPropTrees } from "../parser/jsx/extractProps.mjs";
+import { loadReactNativeStyleProps } from "./styleTypes.mjs";
+import { merge } from "ts-deepmerge";
+
+//#region src/native/server.ts
+const name = "native";
+const settings = new Map([
+	["name", "$$"],
+	["globals", true],
+	["emitRuntime", false]
+]);
+const nativeComponentNames = [
+	"ActivityIndicator",
+	"FlatList",
+	"Image",
+	"Modal",
+	"Pressable",
+	"SafeAreaView",
+	"ScrollView",
+	"SectionList",
+	"Switch",
+	"Text",
+	"TextInput",
+	"TouchableHighlight",
+	"TouchableOpacity",
+	"TouchableWithoutFeedback",
+	"View"
+];
+const defaultTokens = { color: {
+	black: "#000",
+	white: "#fff"
+} };
+let needsRuntime = false;
+const preparedComponents = /* @__PURE__ */ new Map();
+const syncPreparedDts = (api) => {
+	const entries = Array.from(preparedComponents.entries()).sort(([a], [b]) => a.localeCompare(b));
+	const lines = ["interface $$Prepared {"];
+	for (const [name] of entries) {
+		const baseType = "DefaultNativeElement";
+		const getterType = `BaseFn<${baseType}>`;
+		const setterType = `$$PreparedDefinitionForSet<${baseType}>`;
+		lines.push(`    get ${name}(): ${getterType};`);
+		lines.push(`    set ${name}(value: ${setterType});`);
+	}
+	lines.push("}");
+	api.file.native.dts.set("body", "jsx:prepared-interface", lines.join("\n"));
+};
+const onBoot = async (api) => {
+	preparedComponents.clear();
+	needsRuntime = false;
+	const needsRuntimeTest = () => needsRuntime || settings.get("emitRuntime") === true;
+	const proxyVar = api.file.native.import({
+		name: "proxy",
+		from: "boss-css/parser/jsx/native"
+	}, needsRuntimeTest);
+	api.file.native.importAndConfig({
+		name: "onBrowserObjectStart",
+		from: "boss-css/native/browser"
+	}, needsRuntimeTest);
+	settings.get("globals") && api.file.native.set("body", "jsx:globalThis", `globalThis.${settings.get("name")} = ${proxyVar}`, needsRuntimeTest);
+	api.file.native.set("body", "jsx:export-const", `export const ${settings.get("name")} = ${proxyVar}`, needsRuntimeTest);
+	api.file.native.set("foot", "jsx:export-default", `export default ${proxyVar}`, needsRuntimeTest);
+	const tokenCreatorVar = api.file.native.import({
+		name: "create",
+		from: "boss-css/use/token/runtime-only"
+	}, needsRuntimeTest);
+	api.file.native.set("foot", "token:$$.token", `$$.token = ${tokenCreatorVar}()`, needsRuntimeTest);
+	const { props } = await loadReactNativeStyleProps();
+	const nativeStyleProps = Array.from(props.keys()).sort();
+	const mergedTokens = merge(defaultTokens, api.tokens ?? {});
+	api.file.native.config({
+		from: "boss-css/native",
+		config: {
+			nativeStyleProps,
+			tokens: mergedTokens,
+			runtime: { only: true }
+		}
+	}, needsRuntimeTest);
+	api.file.native.dts.set("head", "jsx:runtime", `import type React from 'react'`);
+	api.file.native.dts.set("head", "jsx:native-components", `import type { ${nativeComponentNames.join(", ")} } from 'react-native'`);
+	api.file.native.dts.set("body", "jsx:utils", `type AsProp<C extends React.ElementType> = {
+    as?: C
+}
+type PropsToOmit<C extends React.ElementType, P> = keyof (AsProp<C> & P)
+type PolymorphicComponentProp<C extends React.ElementType, Props = {}> = React.PropsWithChildren<Props & AsProp<C>> &
+    Omit<React.ComponentPropsWithoutRef<C>, PropsToOmit<C, Props>>
+type PolymorphicComponentPropWithRef<C extends React.ElementType, Props = {}> = PolymorphicComponentProp<C, Props> & {
+    ref?: PolymorphicRef<C>
+}
+type PolymorphicRef<C extends React.ElementType> = React.ComponentPropsWithRef<C>['ref']
+
+type DefaultNativeElement = typeof View
+type $$JSXFinalProps<C extends React.ElementType> = PolymorphicComponentPropWithRef<C, $$FinalProps>
+declare const $$PreparedBrand: unique symbol
+type $$PreparedProps<Base extends React.ElementType = DefaultNativeElement, C extends React.ElementType = Base> = Omit<
+    $$JSXFinalProps<C>,
+    'children' | 'ref'
+> &
+    (C extends Base ? { as?: C } : { as: C })
+type $$PreparedDefinition<Base extends React.ElementType = DefaultNativeElement, C extends React.ElementType = Base> =
+    $$PreparedProps<Base, C> & { readonly [typeof $$PreparedBrand]: true }
+type $$PreparedDefinitionForSet<Base extends React.ElementType = DefaultNativeElement> =
+    | $$PreparedDefinition<Base, Base>
+    | {
+          [K in keyof JSX.IntrinsicElements]: $$PreparedDefinition<Base, K> & { as: K }
+      }[keyof JSX.IntrinsicElements]
+type $$NoopFn = {
+    (props: $$PreparedProps<DefaultNativeElement, DefaultNativeElement>): $$PreparedDefinition<DefaultNativeElement, DefaultNativeElement>
+    <C extends React.ElementType>(props: $$PreparedProps<DefaultNativeElement, C> & { as: C }): $$PreparedDefinition<DefaultNativeElement, C>
+    (input: string): string
+}
+type StyleFn = {
+    (...inputs: $$FinalProps[]): BossComponentProps<DefaultNativeElement>
+}
+type CssFn = {
+    (input: TemplateStringsArray, ...exprs: unknown[]): void
+    (input: string | Record<string, unknown>): void
+}
+
+type NativeComponentMap = {
+${nativeComponentNames.map((name) => `    ${name}: typeof ${name};`).join("\n")}
+}
+
+type BaseFn<T extends React.ElementType = DefaultNativeElement> = {
+    <C extends React.ElementType = T, L extends React.LegacyRef>(
+        props: $$JSXFinalProps<C>,
+        contexts?: L,
+    ): L extends React.LegacyRef ? React.ReactNode : $$FinalProps
+}`);
+	syncPreparedDts(api);
+	api.file.native.dts.set("body", "jsx:proxy-start", `type ProxyCustomMembers = {
+`).set("body", "jsx:proxy-utils", `    $: $$NoopFn
+    merge: (...inputs: import('boss-css/merge').MergeInput[]) => import('boss-css/merge').MergeOutput
+    cx: (...inputs: import('boss-css/cx').CxValue[]) => string
+    cv: typeof import('boss-css/cx').cv
+    scv: typeof import('boss-css/cx').scv
+    sv: typeof import('boss-css/cx').sv
+    css: CssFn
+    style: StyleFn
+`).set("body", "jsx:proxy-custom-members", ``).set("body", "jsx:proxy-custom-members-end", `}`).set("body", "jsx:proxy-type", `type Proxy = BaseFn & {
+    [T in keyof NativeComponentMap]: BaseFn<NativeComponentMap[T]>
+} & $$Prepared & ProxyCustomMembers`);
+	api.file.native.dts.set("foot", "jsx:export", `export declare const $$: Proxy`);
+	if (settings.get("globals")) api.file.native.dts.set("foot", "jsx:globals", `declare global {
+    const $$: Proxy
+}`);
+	api.file.native.dts.set("foot", "$$:default-export", `export default $$`);
+	api.file.native.dts.set("body", "native:StylePropsInterfaceStart", `export interface $$NativeStyleProps {`);
+	for (const [name, prop] of props.entries()) {
+		if (prop.description) api.file.native.dts.set("body", `native:${name}:description`, `  /**\n   * ${prop.description}\n   */`);
+		api.file.native.dts.set("body", `native:${name}:declaration`, `  ${name}?: $$PropValues | ${prop.type};\n`);
+	}
+	api.file.native.dts.set("body", "native:StylePropsInterfaceEnd", `}`);
+	api.file.native.dts.replace("body", `$$:FinalProps`, (v) => `${v} & $$NativeStyleProps`);
+	api.file.native.dts.prepend("body", "jsx:proxy-custom-members", `    token: ${JSON.stringify(mergedTokens, null, 4)}\n`);
+};
+const onParse = async (api, input) => {
+	const { content } = input;
+	const results = await extractPropTrees(extractCode(content));
+	needsRuntime ||= !!Object.keys(results).length;
+	const prepared = extractPreparedComponents(content, input.path || input.file);
+	let preparedDirty = false;
+	for (const entry of prepared) {
+		const existing = preparedComponents.get(entry.name);
+		if (!existing || existing.asTag !== entry.asTag || existing.asDynamic !== entry.asDynamic) {
+			preparedComponents.set(entry.name, entry);
+			preparedDirty = true;
+		}
+	}
+	if (preparedDirty) syncPreparedDts(api);
+};
+
+//#endregion
+export { name, onBoot, onParse, settings };

package/dist/native/styleTypes.cjs

@@ -0,0 +1,168 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = require_rolldown_runtime.__toESM(node_fs_promises);
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path);
+let fast_glob = require("fast-glob");
+fast_glob = require_rolldown_runtime.__toESM(fast_glob);
+let node_module = require("node:module");
+
+//#region src/native/styleTypes.ts
+const interfaceNames = new Set([
+	"ViewStyle",
+	"TextStyle",
+	"ImageStyle"
+]);
+const normalizeType = (value) => value.replace(/\s+/g, " ").replace(/;$/, "").trim();
+const parseInterfaces = (source) => {
+	const interfaces = /* @__PURE__ */ new Map();
+	const lines = source.split("\n");
+	let current = null;
+	let comment = [];
+	let pendingProp = null;
+	const interfaceRegexp = /^\s*(?:export\s+)?interface\s+([A-Za-z0-9_]+)(?:\s+extends\s+([^ {]+(?:\s*,\s*[^ {]+)*))?\s*\{/;
+	const propRegexp = /^\s+(?:readonly\s+)?["']?([A-Za-z0-9_]+)["']?\??:\s*(.+)$/;
+	for (const line of lines) {
+		const interfaceMatch = line.match(interfaceRegexp);
+		if (interfaceMatch) {
+			const [, name, extendsRaw] = interfaceMatch;
+			const entry = {
+				name,
+				extends: extendsRaw ? extendsRaw.split(",").map((value) => value.trim()) : [],
+				props: /* @__PURE__ */ new Map()
+			};
+			interfaces.set(name, entry);
+			current = entry;
+			comment = [];
+			pendingProp = null;
+			continue;
+		}
+		if (current && line.trim() === "}") {
+			current = null;
+			comment = [];
+			pendingProp = null;
+			continue;
+		}
+		if (!current) continue;
+		if (line.trim().startsWith("/**")) {
+			const trimmed = line.trim().replace(/^\/\*\* ?/, "");
+			if (trimmed.includes("*/")) comment = [trimmed.replace(/\*\/$/, "").trim()];
+			else comment = [trimmed];
+			continue;
+		}
+		if (comment.length && line.trim().startsWith("*")) {
+			const trimmed = line.trim().replace(/^\* ?/, "");
+			if (!trimmed.endsWith("*/")) {
+				comment.push(trimmed);
+				continue;
+			}
+			comment.push(trimmed.replace(/\*\/$/, "").trim());
+			continue;
+		}
+		if (pendingProp) {
+			pendingProp.type += ` ${line.trim()}`;
+			if (line.includes(";")) {
+				const propType = normalizeType(pendingProp.type);
+				current.props.set(pendingProp.name, {
+					name: pendingProp.name,
+					type: propType,
+					description: comment.join("\n").trim() || void 0
+				});
+				pendingProp = null;
+				comment = [];
+			}
+			continue;
+		}
+		const propMatch = line.match(propRegexp);
+		if (!propMatch) continue;
+		const [, rawName, typeRaw] = propMatch;
+		if (rawName.startsWith("[")) continue;
+		const typeValue = typeRaw.trim();
+		if (!line.includes(";")) {
+			pendingProp = {
+				name: rawName,
+				type: typeValue
+			};
+			continue;
+		}
+		current.props.set(rawName, {
+			name: rawName,
+			type: normalizeType(typeValue),
+			description: comment.join("\n").trim() || void 0
+		});
+		comment = [];
+	}
+	return interfaces;
+};
+const mergeProps = (target, source) => {
+	for (const [name, prop] of source.entries()) {
+		const existing = target.get(name);
+		if (!existing) {
+			target.set(name, { ...prop });
+			continue;
+		}
+		if (existing.type !== prop.type) {
+			const types = new Set([existing.type, prop.type]);
+			existing.type = Array.from(types).join(" | ");
+		}
+		if (!existing.description && prop.description) existing.description = prop.description;
+	}
+};
+const collectProps = (name, interfaces, visited = /* @__PURE__ */ new Set()) => {
+	if (visited.has(name)) return /* @__PURE__ */ new Map();
+	visited.add(name);
+	const entry = interfaces.get(name);
+	if (!entry) return /* @__PURE__ */ new Map();
+	const merged = /* @__PURE__ */ new Map();
+	for (const parent of entry.extends) mergeProps(merged, collectProps(parent, interfaces, visited));
+	mergeProps(merged, entry.props);
+	return merged;
+};
+const resolveReactNativeRoot = async () => {
+	const require = (0, node_module.createRequire)(process.cwd() + "/package.json");
+	let packageJsonPath;
+	try {
+		packageJsonPath = require.resolve("react-native/package.json");
+	} catch (error) {
+		throw new Error("native: react-native is not installed in this project.");
+	}
+	const packageJson = JSON.parse(await node_fs_promises.default.readFile(packageJsonPath, "utf-8"));
+	return {
+		root: node_path.default.dirname(packageJsonPath),
+		typesEntry: packageJson.types || packageJson.typings
+	};
+};
+const findStyleSheetTypesFile = async (root, typesEntry) => {
+	const candidates = await (0, fast_glob.default)(["**/StyleSheetTypes.d.ts", "**/StyleSheetTypes.ts"], {
+		cwd: root,
+		absolute: true,
+		suppressErrors: true
+	});
+	if (candidates.length) return candidates[0];
+	if (typesEntry) {
+		const entryPath = node_path.default.join(root, typesEntry);
+		if ((await node_fs_promises.default.readFile(entryPath, "utf-8").catch(() => "")).includes("interface ViewStyle")) return entryPath;
+	}
+	const fallback = await (0, fast_glob.default)(["**/*.d.ts"], {
+		cwd: root,
+		absolute: true,
+		suppressErrors: true
+	});
+	for (const file of fallback) if ((await node_fs_promises.default.readFile(file, "utf-8").catch(() => "")).includes("interface ViewStyle")) return file;
+	return null;
+};
+const loadReactNativeStyleProps = async () => {
+	const { root, typesEntry } = await resolveReactNativeRoot();
+	const typesFile = await findStyleSheetTypesFile(root, typesEntry);
+	if (!typesFile) throw new Error("native: unable to locate React Native style type definitions.");
+	const interfaces = parseInterfaces(await node_fs_promises.default.readFile(typesFile, "utf-8"));
+	const merged = /* @__PURE__ */ new Map();
+	for (const name of interfaceNames) mergeProps(merged, collectProps(name, interfaces));
+	return {
+		props: merged,
+		sourcePath: typesFile
+	};
+};
+
+//#endregion
+exports.loadReactNativeStyleProps = loadReactNativeStyleProps;