@xyd-js/source-react-runtime 0.0.0-build-23166ce-20260423151359

package/dist/esbuild.js

@@ -0,0 +1,378 @@
+// src/esbuild.ts
+import * as fs from "fs";
+
+// src/index.ts
+import * as path from "path";
+
+// src/json-schema-to-uniform.ts
+import {
+  schemaObjectToUniformDefinitionProperties
+} from "@xyd-js/openapi";
+function jsonSchemaToUniformReference(componentName, schema) {
+  var _a;
+  const ref = {
+    title: componentName,
+    canonical: "",
+    description: "",
+    definitions: [],
+    examples: { groups: [] }
+  };
+  const rootSchema = resolveRootSchema(schema);
+  if (!rootSchema) return ref;
+  const schemas = ((_a = schema.components) == null ? void 0 : _a.schemas) || {};
+  const inlined = inlineRefs(rootSchema, schemas);
+  const result = schemaObjectToUniformDefinitionProperties(inlined);
+  const propsDef = {
+    title: "Props",
+    properties: [],
+    meta: [{ name: "type", value: "parameters" }]
+  };
+  if (Array.isArray(result)) {
+    propsDef.properties = result;
+  } else if (result) {
+    propsDef.rootProperty = result;
+  }
+  if (propsDef.properties.length > 0 || propsDef.rootProperty) {
+    ref.definitions.push(propsDef);
+  }
+  return ref;
+}
+function resolveRootSchema(output) {
+  var _a, _b, _c;
+  const rootRef = (_a = output.schemas) == null ? void 0 : _a[0];
+  if (!rootRef) return null;
+  if ("$ref" in rootRef && rootRef.$ref) {
+    const refPath = rootRef.$ref.replace("#/components/schemas/", "");
+    return ((_c = (_b = output.components) == null ? void 0 : _b.schemas) == null ? void 0 : _c[refPath]) || null;
+  }
+  return rootRef;
+}
+function inlineRefs(schema, schemas, visited = /* @__PURE__ */ new Set()) {
+  if (!schema || typeof schema !== "object") return schema;
+  if (schema.$ref) {
+    const refPath = schema.$ref.replace("#/components/schemas/", "");
+    if (visited.has(refPath)) {
+      return { type: "object", description: `(circular: ${refPath})` };
+    }
+    const resolved = schemas[refPath];
+    if (!resolved) return schema;
+    visited.add(refPath);
+    const result2 = inlineRefs({ ...resolved }, schemas, visited);
+    visited.delete(refPath);
+    return result2;
+  }
+  if (Array.isArray(schema)) {
+    return schema.map((item) => inlineRefs(item, schemas, visited));
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(schema)) {
+    result[key] = inlineRefs(value, schemas, visited);
+  }
+  return result;
+}
+
+// src/index.ts
+function xydSourceReactRuntime(options) {
+  let transformedFiles = /* @__PURE__ */ new Map();
+  const propName = (options == null ? void 0 : options.propertyName) || "__xydUniform";
+  return {
+    name: "xyd-source-react-runtime",
+    enforce: "pre",
+    async buildStart() {
+      const tsconfigPath = (options == null ? void 0 : options.tsconfig) || path.resolve(process.cwd(), "tsconfig.json");
+      transformedFiles = await buildTypiaSchemas(tsconfigPath);
+    },
+    // Vite path: transform hook receives the original code
+    transform(code, id) {
+      if (!id.match(/\.[jt]sx?$/)) return null;
+      const transformed = transformedFiles.get(path.resolve(id));
+      if (!transformed) return null;
+      return convertSchemaToUniform(transformed, propName);
+    },
+    // Rollup path: load hook returns our compiled JS before Rollup's parser
+    load(id) {
+      if (!id.match(/\.[jt]sx?$/)) return null;
+      const transformed = transformedFiles.get(path.resolve(id));
+      if (!transformed) return null;
+      return convertSchemaToUniform(transformed, propName);
+    }
+  };
+}
+async function buildTypiaSchemas(tsconfigPath) {
+  const result = /* @__PURE__ */ new Map();
+  let ts;
+  let typiaTransformModule;
+  try {
+    ts = await import("typescript");
+    typiaTransformModule = await import("typia/lib/transform");
+  } catch {
+    console.warn("[xyd-source-react-runtime] typia or typescript not found");
+    return result;
+  }
+  const configFile = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
+  const parsedConfig = ts.parseJsonConfigFileContent(
+    configFile.config,
+    ts.sys,
+    path.dirname(tsconfigPath)
+  );
+  const componentsByFile = /* @__PURE__ */ new Map();
+  for (const fileName of parsedConfig.fileNames) {
+    const content = ts.sys.readFile(fileName);
+    if (!content) continue;
+    const components = detectComponents(ts, content, fileName);
+    if (components.length > 0) {
+      componentsByFile.set(fileName, components);
+    }
+  }
+  if (componentsByFile.size === 0) return result;
+  const modifiedSources = /* @__PURE__ */ new Map();
+  for (const [fileName, components] of componentsByFile) {
+    const supported = components.filter((c) => !c.propsType.includes("React."));
+    if (supported.length === 0) continue;
+    const original = ts.sys.readFile(fileName);
+    let modified = `import typia from "typia";
+${original}`;
+    for (const comp of supported) {
+      modified += `
+${comp.name}.__xydSchema = typia.json.schemas<[${comp.propsType}]>();`;
+    }
+    modifiedSources.set(fileName, modified);
+  }
+  const compilerHost = ts.createCompilerHost(parsedConfig.options);
+  const origGetSourceFile = compilerHost.getSourceFile;
+  const origFileExists = compilerHost.fileExists;
+  const origReadFile = compilerHost.readFile;
+  compilerHost.getSourceFile = (name, languageVersion, onError) => {
+    const resolved = path.resolve(name);
+    const modified = modifiedSources.get(resolved);
+    if (modified) {
+      return ts.createSourceFile(
+        name,
+        modified,
+        languageVersion,
+        true,
+        name.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS
+      );
+    }
+    return origGetSourceFile.call(compilerHost, name, languageVersion, onError);
+  };
+  compilerHost.fileExists = (name) => {
+    if (modifiedSources.has(path.resolve(name))) return true;
+    return origFileExists.call(compilerHost, name);
+  };
+  compilerHost.readFile = (name) => {
+    const modified = modifiedSources.get(path.resolve(name));
+    if (modified) return modified;
+    return origReadFile.call(compilerHost, name);
+  };
+  const program = ts.createProgram({
+    rootNames: parsedConfig.fileNames,
+    options: { ...parsedConfig.options, noEmit: false, declaration: false, sourceMap: false },
+    host: compilerHost
+  });
+  const factory = (typiaTransformModule.default || typiaTransformModule)(program);
+  for (const fileName of componentsByFile.keys()) {
+    const sourceFile = program.getSourceFile(fileName);
+    if (!sourceFile) continue;
+    try {
+      let output = "";
+      program.emit(
+        sourceFile,
+        (_name, text) => {
+          if (!_name.endsWith(".d.ts")) {
+            output = text;
+          }
+        },
+        void 0,
+        false,
+        { before: [factory] }
+      );
+      if (output) {
+        result.set(path.resolve(fileName), output);
+      }
+    } catch (e) {
+      console.warn(`[xyd-source-react-runtime] typia transform failed for ${fileName}, skipping`);
+    }
+  }
+  return result;
+}
+function detectComponents(ts, code, fileName) {
+  const sourceFile = ts.createSourceFile(
+    fileName,
+    code,
+    ts.ScriptTarget.Latest,
+    true,
+    fileName.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS
+  );
+  const components = [];
+  ts.forEachChild(sourceFile, (node) => {
+    if (ts.isFunctionDeclaration(node) && node.name && isExported(ts, node)) {
+      const name = node.name.text;
+      if (!isPascalCase(name)) return;
+      const propsType = extractPropsType(ts, node, sourceFile);
+      if (propsType) {
+        components.push({ name, propsType, fileName });
+      }
+    }
+    if (ts.isVariableStatement(node) && isExported(ts, node)) {
+      for (const decl of node.declarationList.declarations) {
+        if (!ts.isIdentifier(decl.name)) continue;
+        const name = decl.name.text;
+        if (!isPascalCase(name)) continue;
+        if (!decl.initializer) continue;
+        if (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer)) {
+          const propsType = extractPropsTypeFromParams(ts, decl.initializer.parameters, sourceFile);
+          if (propsType) {
+            components.push({ name, propsType, fileName });
+          }
+          continue;
+        }
+        const contextType = extractCreateContextType(ts, decl.initializer, sourceFile);
+        if (contextType) {
+          components.push({ name, propsType: contextType, fileName });
+        }
+      }
+    }
+  });
+  const foundNames = new Set(components.map((c) => c.name));
+  const reExportedNames = /* @__PURE__ */ new Set();
+  ts.forEachChild(sourceFile, (node) => {
+    if (ts.isExportDeclaration(node) && node.exportClause && ts.isNamedExports(node.exportClause)) {
+      for (const spec of node.exportClause.elements) {
+        reExportedNames.add(spec.name.text);
+      }
+    }
+  });
+  ts.forEachChild(sourceFile, (node) => {
+    if (ts.isFunctionDeclaration(node) && node.name && !isExported(ts, node)) {
+      const name = node.name.text;
+      if (!isPascalCase(name) || foundNames.has(name) || !reExportedNames.has(name)) return;
+      const propsType = extractPropsType(ts, node, sourceFile);
+      if (propsType) {
+        components.push({ name, propsType, fileName });
+        foundNames.add(name);
+      }
+    }
+    if (ts.isVariableStatement(node) && !isExported(ts, node)) {
+      for (const decl of node.declarationList.declarations) {
+        if (!ts.isIdentifier(decl.name)) continue;
+        const name = decl.name.text;
+        if (!isPascalCase(name) || foundNames.has(name) || !reExportedNames.has(name)) continue;
+        if (!decl.initializer) continue;
+        if (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer)) {
+          const propsType = extractPropsTypeFromParams(ts, decl.initializer.parameters, sourceFile);
+          if (propsType) {
+            components.push({ name, propsType, fileName });
+            foundNames.add(name);
+          }
+          continue;
+        }
+        const contextType = extractCreateContextType(ts, decl.initializer, sourceFile);
+        if (contextType) {
+          components.push({ name, propsType: contextType, fileName });
+          foundNames.add(name);
+        }
+      }
+    }
+  });
+  return components;
+}
+function extractCreateContextType(ts, initializer, sourceFile) {
+  if (!ts.isCallExpression(initializer)) return null;
+  const callee = initializer.expression;
+  const isCreateContext = ts.isIdentifier(callee) && callee.text === "createContext" || ts.isPropertyAccessExpression(callee) && callee.name.text === "createContext";
+  if (!isCreateContext) return null;
+  const typeArgs = initializer.typeArguments;
+  if (!typeArgs || typeArgs.length === 0) return null;
+  const typeArg = typeArgs[0];
+  if (ts.isUnionTypeNode(typeArg)) {
+    const nonNullTypes = typeArg.types.filter(
+      (t) => !(ts.isLiteralTypeNode(t) && t.literal.kind === ts.SyntaxKind.NullKeyword) && !(t.kind === ts.SyntaxKind.UndefinedKeyword)
+    );
+    if (nonNullTypes.length === 1) {
+      return nonNullTypes[0].getText(sourceFile);
+    }
+    return nonNullTypes.map((t) => t.getText(sourceFile)).join(" | ");
+  }
+  return typeArg.getText(sourceFile);
+}
+function isExported(ts, node) {
+  var _a;
+  return ((_a = node.modifiers) == null ? void 0 : _a.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)) ?? false;
+}
+function isPascalCase(name) {
+  return /^[A-Z]/.test(name);
+}
+function extractPropsType(ts, node, sourceFile) {
+  return extractPropsTypeFromParams(ts, node.parameters, sourceFile);
+}
+function extractPropsTypeFromParams(ts, parameters, sourceFile) {
+  if (parameters.length === 0) return null;
+  const firstParam = parameters[0];
+  if (firstParam.type && ts.isTypeReferenceNode(firstParam.type)) {
+    return firstParam.type.getText(sourceFile);
+  }
+  if (firstParam.type && ts.isTypeReferenceNode(firstParam.type) && ts.isObjectBindingPattern(firstParam.name)) {
+    return firstParam.type.getText(sourceFile);
+  }
+  if (ts.isObjectBindingPattern(firstParam.name) && firstParam.type) {
+    return firstParam.type.getText(sourceFile);
+  }
+  return null;
+}
+function convertSchemaToUniform(code, propertyName = "__xydUniform") {
+  const schemaRegex = /(\w+)\.__xydSchema\s*=\s*(\{[\s\S]*?\n\});/g;
+  let modified = code;
+  let hasChanges = false;
+  let match;
+  while ((match = schemaRegex.exec(code)) !== null) {
+    const componentName = match[1];
+    const schemaStr = match[2];
+    try {
+      const schema = new Function(`return ${schemaStr}`)();
+      const uniform = jsonSchemaToUniformReference(componentName, schema);
+      const jsonStr = JSON.stringify(uniform).replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+      modified = modified.replace(
+        match[0],
+        `${componentName}.${propertyName} = JSON.parse('${jsonStr}');`
+      );
+      hasChanges = true;
+    } catch (e) {
+      console.warn(`[xyd-source-react-runtime] Failed to parse schema for ${componentName}:`, e);
+    }
+  }
+  if (!hasChanges) return null;
+  return { code: modified, map: null };
+}
+
+// src/esbuild.ts
+function xydSourceReactRuntimeEsbuild(options) {
+  const vitePlugin = xydSourceReactRuntime(options);
+  return {
+    name: "xyd-source-react-runtime",
+    setup(build) {
+      build.onStart(async () => {
+        if (typeof vitePlugin.buildStart === "function") {
+          await vitePlugin.buildStart.call(vitePlugin);
+        }
+      });
+      build.onLoad({ filter: /\.[jt]sx?$/ }, async (args) => {
+        var _a, _b, _c, _d;
+        const code = fs.readFileSync(args.path, "utf-8");
+        const result = ((_b = (_a = vitePlugin.transform) == null ? void 0 : _a.call) == null ? void 0 : _b.call(_a, vitePlugin, code, args.path)) ?? ((_d = (_c = vitePlugin.load) == null ? void 0 : _c.call) == null ? void 0 : _d.call(_c, vitePlugin, args.path));
+        if (result) {
+          const contents = typeof result === "string" ? result : result.code;
+          return {
+            contents,
+            loader: args.path.endsWith(".tsx") ? "tsx" : args.path.endsWith(".ts") ? "ts" : "js"
+          };
+        }
+        return void 0;
+      });
+    }
+  };
+}
+export {
+  xydSourceReactRuntimeEsbuild
+};
+//# sourceMappingURL=esbuild.js.map

package/dist/esbuild.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/esbuild.ts","../src/index.ts","../src/json-schema-to-uniform.ts"],"sourcesContent":["import * as fs from 'node:fs';\nimport type {Plugin as EsbuildPlugin} from 'esbuild';\nimport {xydSourceReactRuntime, type XydSourceReactRuntimeOptions} from './index';\n\n/**\n * esbuild plugin adapter for xyd-source-react-runtime.\n *\n * ```js\n * import {xydSourceReactRuntimeEsbuild} from '@xyd-js/source-react-runtime/esbuild';\n *\n * await esbuild.build({\n *     entryPoints: ['src/index.ts'],\n *     plugins: [xydSourceReactRuntimeEsbuild({tsconfig: './tsconfig.json'})],\n * });\n * ```\n */\nexport function xydSourceReactRuntimeEsbuild(options?: XydSourceReactRuntimeOptions): EsbuildPlugin {\n    const vitePlugin = xydSourceReactRuntime(options);\n\n    return {\n        name: 'xyd-source-react-runtime',\n        setup(build) {\n            build.onStart(async () => {\n                if (typeof (vitePlugin as any).buildStart === 'function') {\n                    await (vitePlugin as any).buildStart.call(vitePlugin);\n                }\n            });\n\n            build.onLoad({filter: /\\.[jt]sx?$/}, async (args) => {\n                const code = fs.readFileSync(args.path, 'utf-8');\n                const result = (vitePlugin as any).transform?.call?.(vitePlugin, code, args.path)\n                    ?? (vitePlugin as any).load?.call?.(vitePlugin, args.path);\n\n                if (result) {\n                    const contents = typeof result === 'string' ? result : result.code;\n                    return {\n                        contents,\n                        loader: args.path.endsWith('.tsx') ? 'tsx' : args.path.endsWith('.ts') ? 'ts' : 'js',\n                    };\n                }\n                return undefined;\n            });\n        },\n    };\n}\n","import * as path from 'node:path';\nimport * as fs from 'node:fs';\nimport type {Plugin} from 'vite';\nimport {jsonSchemaToUniformReference} from './json-schema-to-uniform';\n\nexport {jsonSchemaToUniformReference} from './json-schema-to-uniform';\n\nexport interface XydSourceReactRuntimeOptions {\n    /** Path to tsconfig.json. Required for typia's TypeScript transform. */\n    tsconfig?: string;\n    /** Property name for the injected uniform data. Defaults to `__xydUniform`. */\n    propertyName?: string;\n}\n\ninterface ComponentInfo {\n    name: string;\n    propsType: string;\n    fileName: string;\n}\n\n/**\n * Vite plugin that auto-detects React components, uses typia to generate\n * JSON Schema from their props at build time, and injects `__xydUniform`.\n *\n * No manual annotations needed — the plugin:\n * 1. Scans source files for exported functions with typed props\n * 2. Injects `typia.json.schemas<[PropsType]>()` calls\n * 3. Runs typia's TS transform to resolve all types (cross-file, generics, etc.)\n * 4. Converts JSON Schema → xyd uniform format\n * 5. Injects `Component.__xydUniform = JSON.parse('...')`\n *\n * ```ts\n * import react from '@vitejs/plugin-react';\n * import { xydSourceReactRuntime } from '@xyd-js/source-react-runtime';\n *\n * export default defineConfig({\n *   plugins: [\n *     xydSourceReactRuntime({ tsconfig: './tsconfig.json' }),\n *     react(),\n *   ],\n * });\n * ```\n */\nexport function xydSourceReactRuntime(options?: XydSourceReactRuntimeOptions): Plugin {\n    // Map of fileName → typia-transformed output with __xydSchema injected\n    let transformedFiles: Map<string, string> = new Map();\n    const propName = options?.propertyName || '__xydUniform';\n\n    return {\n        name: 'xyd-source-react-runtime',\n        enforce: 'pre',\n\n        async buildStart() {\n            const tsconfigPath = options?.tsconfig || path.resolve(process.cwd(), 'tsconfig.json');\n            transformedFiles = await buildTypiaSchemas(tsconfigPath);\n        },\n\n        // Vite path: transform hook receives the original code\n        transform(code, id) {\n            if (!id.match(/\\.[jt]sx?$/)) return null;\n\n            const transformed = transformedFiles.get(path.resolve(id));\n            if (!transformed) return null;\n\n            return convertSchemaToUniform(transformed, propName);\n        },\n\n        // Rollup path: load hook returns our compiled JS before Rollup's parser\n        load(id) {\n            if (!id.match(/\\.[jt]sx?$/)) return null;\n\n            const transformed = transformedFiles.get(path.resolve(id));\n            if (!transformed) return null;\n\n            return convertSchemaToUniform(transformed, propName);\n        },\n    };\n}\n\n/**\n * Scans all source files, detects React components, injects typia calls,\n * and runs typia transform to generate JSON schemas.\n */\nasync function buildTypiaSchemas(tsconfigPath: string): Promise<Map<string, string>> {\n    const result = new Map<string, string>();\n\n    let ts: typeof import('typescript');\n    let typiaTransformModule: any;\n\n    try {\n        ts = await import('typescript');\n        typiaTransformModule = await import('typia/lib/transform');\n    } catch {\n        console.warn('[xyd-source-react-runtime] typia or typescript not found');\n        return result;\n    }\n\n    const configFile = ts.readConfigFile(tsconfigPath, ts.sys.readFile);\n    const parsedConfig = ts.parseJsonConfigFileContent(\n        configFile.config,\n        ts.sys,\n        path.dirname(tsconfigPath),\n    );\n\n    // Step 1: Scan source files for exported React components\n    const componentsByFile = new Map<string, ComponentInfo[]>();\n\n    for (const fileName of parsedConfig.fileNames) {\n        const content = ts.sys.readFile(fileName);\n        if (!content) continue;\n\n        const components = detectComponents(ts, content, fileName);\n        if (components.length > 0) {\n            componentsByFile.set(fileName, components);\n        }\n    }\n\n    if (componentsByFile.size === 0) return result;\n\n    // Step 2: Create modified source files with typia calls injected\n    const modifiedSources = new Map<string, string>();\n\n    for (const [fileName, components] of componentsByFile) {\n        // Filter out components whose propsType is an inline type literal with\n        // React types (e.g. { children: React.ReactNode }) — typia can't resolve these\n        const supported = components.filter(c => !c.propsType.includes('React.'));\n\n        if (supported.length === 0) continue;\n\n        const original = ts.sys.readFile(fileName)!;\n        let modified = `import typia from \"typia\";\\n${original}`;\n\n        for (const comp of supported) {\n            modified += `\\n${comp.name}.__xydSchema = typia.json.schemas<[${comp.propsType}]>();`;\n        }\n\n        modifiedSources.set(fileName, modified);\n    }\n\n    // Step 3: Create a TS program with modified sources for typia transform\n    const compilerHost = ts.createCompilerHost(parsedConfig.options);\n    const origGetSourceFile = compilerHost.getSourceFile;\n    const origFileExists = compilerHost.fileExists;\n    const origReadFile = compilerHost.readFile;\n\n    compilerHost.getSourceFile = (name, languageVersion, onError) => {\n        const resolved = path.resolve(name);\n        const modified = modifiedSources.get(resolved);\n        if (modified) {\n            return ts.createSourceFile(\n                name, modified, languageVersion, true,\n                name.endsWith('.tsx') ? ts.ScriptKind.TSX : ts.ScriptKind.TS,\n            );\n        }\n        return origGetSourceFile.call(compilerHost, name, languageVersion, onError);\n    };\n\n    compilerHost.fileExists = (name) => {\n        if (modifiedSources.has(path.resolve(name))) return true;\n        return origFileExists.call(compilerHost, name);\n    };\n\n    compilerHost.readFile = (name) => {\n        const modified = modifiedSources.get(path.resolve(name));\n        if (modified) return modified;\n        return origReadFile.call(compilerHost, name);\n    };\n\n    const program = ts.createProgram({\n        rootNames: parsedConfig.fileNames,\n        options: {...parsedConfig.options, noEmit: false, declaration: false, sourceMap: false},\n        host: compilerHost,\n    });\n\n    const factory = (typiaTransformModule.default || typiaTransformModule)(program);\n\n    // Step 4: Emit typia-transformed output for each file with components\n    for (const fileName of componentsByFile.keys()) {\n        const sourceFile = program.getSourceFile(fileName);\n        if (!sourceFile) continue;\n\n        try {\n            let output = '';\n            program.emit(\n                sourceFile,\n                (_name: string, text: string) => {\n                    if (!_name.endsWith('.d.ts')) {\n                        output = text;\n                    }\n                },\n                undefined,\n                false,\n                {before: [factory]},\n            );\n\n            if (output) {\n                result.set(path.resolve(fileName), output);\n            }\n        } catch (e) {\n            // typia transform can fail on files with unresolvable types (e.g. React.ReactNode)\n            // Skip these files — their components won't get __xydUniform\n            console.warn(`[xyd-source-react-runtime] typia transform failed for ${fileName}, skipping`);\n        }\n    }\n\n    return result;\n}\n\n/**\n * Detects exported React components and their props type names using TS AST.\n */\nfunction detectComponents(\n    ts: typeof import('typescript'),\n    code: string,\n    fileName: string,\n): ComponentInfo[] {\n    const sourceFile = ts.createSourceFile(\n        fileName, code, ts.ScriptTarget.Latest, true,\n        fileName.endsWith('.tsx') ? ts.ScriptKind.TSX : ts.ScriptKind.TS,\n    );\n\n    const components: ComponentInfo[] = [];\n\n    ts.forEachChild(sourceFile, (node) => {\n        // export function ComponentName(props: PropsType) { ... }\n        if (ts.isFunctionDeclaration(node) && node.name && isExported(ts, node)) {\n            const name = node.name.text;\n            if (!isPascalCase(name)) return;\n\n            const propsType = extractPropsType(ts, node, sourceFile);\n            if (propsType) {\n                components.push({name, propsType, fileName});\n            }\n        }\n\n        // export const ComponentName = (props: PropsType) => { ... }\n        // export const SomeContext = createContext<ValueType>(...)\n        if (ts.isVariableStatement(node) && isExported(ts, node)) {\n            for (const decl of node.declarationList.declarations) {\n                if (!ts.isIdentifier(decl.name)) continue;\n                const name = decl.name.text;\n                if (!isPascalCase(name)) continue;\n\n                if (!decl.initializer) continue;\n\n                // Arrow function / function expression → component\n                if (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer)) {\n                    const propsType = extractPropsTypeFromParams(ts, decl.initializer.parameters, sourceFile);\n                    if (propsType) {\n                        components.push({name, propsType, fileName});\n                    }\n                    continue;\n                }\n\n                // createContext<T>(...) → context\n                const contextType = extractCreateContextType(ts, decl.initializer, sourceFile);\n                if (contextType) {\n                    components.push({name, propsType: contextType, fileName});\n                }\n            }\n        }\n    });\n\n    // Also detect non-inline exports: declarations + export { Name }\n    // Collect all PascalCase declarations that weren't already found\n    const foundNames = new Set(components.map(c => c.name));\n    const reExportedNames = new Set<string>();\n\n    // Find all names in export { ... } blocks\n    ts.forEachChild(sourceFile, (node) => {\n        if (ts.isExportDeclaration(node) && node.exportClause && ts.isNamedExports(node.exportClause)) {\n            for (const spec of node.exportClause.elements) {\n                reExportedNames.add(spec.name.text);\n            }\n        }\n    });\n\n    // Find non-exported declarations that are re-exported\n    ts.forEachChild(sourceFile, (node) => {\n        // function Name(...) { ... } (not exported inline)\n        if (ts.isFunctionDeclaration(node) && node.name && !isExported(ts, node)) {\n            const name = node.name.text;\n            if (!isPascalCase(name) || foundNames.has(name) || !reExportedNames.has(name)) return;\n\n            const propsType = extractPropsType(ts, node, sourceFile);\n            if (propsType) {\n                components.push({name, propsType, fileName});\n                foundNames.add(name);\n            }\n        }\n\n        // const Name = createContext<T>(...) or const Name = (...) => { ... }\n        if (ts.isVariableStatement(node) && !isExported(ts, node)) {\n            for (const decl of node.declarationList.declarations) {\n                if (!ts.isIdentifier(decl.name)) continue;\n                const name = decl.name.text;\n                if (!isPascalCase(name) || foundNames.has(name) || !reExportedNames.has(name)) continue;\n                if (!decl.initializer) continue;\n\n                // Arrow/function expression\n                if (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer)) {\n                    const propsType = extractPropsTypeFromParams(ts, decl.initializer.parameters, sourceFile);\n                    if (propsType) {\n                        components.push({name, propsType, fileName});\n                        foundNames.add(name);\n                    }\n                    continue;\n                }\n\n                // createContext<T>(...)\n                const contextType = extractCreateContextType(ts, decl.initializer, sourceFile);\n                if (contextType) {\n                    components.push({name, propsType: contextType, fileName});\n                    foundNames.add(name);\n                }\n            }\n        }\n    });\n\n    return components;\n}\n\n/**\n * Extracts the type argument from createContext<T>() calls.\n * Handles: createContext<T | null>() → strips null from union, returns T.\n */\nfunction extractCreateContextType(\n    ts: typeof import('typescript'),\n    initializer: import('typescript').Expression,\n    sourceFile: import('typescript').SourceFile,\n): string | null {\n    if (!ts.isCallExpression(initializer)) return null;\n\n    // Match createContext(...) or React.createContext(...)\n    const callee = initializer.expression;\n    const isCreateContext =\n        (ts.isIdentifier(callee) && callee.text === 'createContext') ||\n        (ts.isPropertyAccessExpression(callee) && callee.name.text === 'createContext');\n\n    if (!isCreateContext) return null;\n\n    // Get type arguments: createContext<T>(...)\n    const typeArgs = initializer.typeArguments;\n    if (!typeArgs || typeArgs.length === 0) return null;\n\n    const typeArg = typeArgs[0];\n\n    // If it's a union like T | null, strip null/undefined and return T\n    if (ts.isUnionTypeNode(typeArg)) {\n        const nonNullTypes = typeArg.types.filter(\n            (t) => !(ts.isLiteralTypeNode(t) && t.literal.kind === ts.SyntaxKind.NullKeyword) &&\n                   !(t.kind === ts.SyntaxKind.UndefinedKeyword),\n        );\n        if (nonNullTypes.length === 1) {\n            return nonNullTypes[0].getText(sourceFile);\n        }\n        // Multiple non-null types — keep as union\n        return nonNullTypes.map(t => t.getText(sourceFile)).join(' | ');\n    }\n\n    return typeArg.getText(sourceFile);\n}\n\nfunction isExported(ts: typeof import('typescript'), node: any): boolean {\n    return node.modifiers?.some((m: any) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;\n}\n\nfunction isPascalCase(name: string): boolean {\n    return /^[A-Z]/.test(name);\n}\n\nfunction extractPropsType(\n    ts: typeof import('typescript'),\n    node: import('typescript').FunctionDeclaration,\n    sourceFile: import('typescript').SourceFile,\n): string | null {\n    return extractPropsTypeFromParams(ts, node.parameters, sourceFile);\n}\n\nfunction extractPropsTypeFromParams(\n    ts: typeof import('typescript'),\n    parameters: import('typescript').NodeArray<import('typescript').ParameterDeclaration>,\n    sourceFile: import('typescript').SourceFile,\n): string | null {\n    if (parameters.length === 0) return null;\n\n    const firstParam = parameters[0];\n\n    // props: PropsType\n    if (firstParam.type && ts.isTypeReferenceNode(firstParam.type)) {\n        return firstParam.type.getText(sourceFile);\n    }\n\n    // { prop1, prop2 }: PropsType\n    if (firstParam.type && ts.isTypeReferenceNode(firstParam.type) && ts.isObjectBindingPattern(firstParam.name)) {\n        return firstParam.type.getText(sourceFile);\n    }\n\n    // Destructured with type annotation: ({ prop1, prop2 }: PropsType)\n    if (ts.isObjectBindingPattern(firstParam.name) && firstParam.type) {\n        return firstParam.type.getText(sourceFile);\n    }\n\n    return null;\n}\n\n/**\n * Finds __xydSchema assignments and converts JSON Schema → xyd uniform format.\n */\nfunction convertSchemaToUniform(code: string, propertyName: string = '__xydUniform'): {code: string; map: null} | null {\n    const schemaRegex = /(\\w+)\\.__xydSchema\\s*=\\s*(\\{[\\s\\S]*?\\n\\});/g;\n    let modified = code;\n    let hasChanges = false;\n\n    let match: RegExpExecArray | null;\n    while ((match = schemaRegex.exec(code)) !== null) {\n        const componentName = match[1];\n        const schemaStr = match[2];\n\n        try {\n            const schema = new Function(`return ${schemaStr}`)();\n            const uniform = jsonSchemaToUniformReference(componentName, schema);\n            const jsonStr = JSON.stringify(uniform).replace(/\\\\/g, '\\\\\\\\').replace(/'/g, \"\\\\'\");\n\n            modified = modified.replace(\n                match[0],\n                `${componentName}.${propertyName} = JSON.parse('${jsonStr}');`,\n            );\n            hasChanges = true;\n        } catch (e) {\n            console.warn(`[xyd-source-react-runtime] Failed to parse schema for ${componentName}:`, e);\n        }\n    }\n\n    if (!hasChanges) return null;\n    return {code: modified, map: null};\n}\n","import type {\n    Reference,\n    Definition,\n} from '@xyd-js/uniform';\n\nimport {\n    schemaObjectToUniformDefinitionProperties,\n} from '@xyd-js/openapi';\n\n/**\n * JSON Schema structure as produced by typia.json.schemas<[T]>().\n */\ninterface JsonSchemaOutput {\n    version?: string;\n    components?: {\n        schemas?: Record<string, any>;\n    };\n    schemas?: Array<{$ref?: string} | any>;\n}\n\n/**\n * Converts a typia JSON Schema output into an xyd uniform Reference,\n * reusing xyd-openapi's battle-tested schema → uniform converter.\n */\nexport function jsonSchemaToUniformReference(\n    componentName: string,\n    schema: JsonSchemaOutput,\n): Reference {\n    const ref: Reference = {\n        title: componentName,\n        canonical: '',\n        description: '',\n        definitions: [],\n        examples: {groups: []},\n    };\n\n    // Resolve the root schema (follows $ref to components.schemas)\n    const rootSchema = resolveRootSchema(schema);\n    if (!rootSchema) return ref;\n\n    // Inline all $ref pointers so xyd-openapi doesn't encounter unresolved refs\n    const schemas = schema.components?.schemas || {};\n    const inlined = inlineRefs(rootSchema, schemas);\n\n    // Use xyd-openapi's converter\n    const result = schemaObjectToUniformDefinitionProperties(inlined as any);\n\n    const propsDef: Definition = {\n        title: 'Props',\n        properties: [],\n        meta: [{name: 'type' as any, value: 'parameters'}],\n    };\n\n    if (Array.isArray(result)) {\n        propsDef.properties = result;\n    } else if (result) {\n        propsDef.rootProperty = result;\n    }\n\n    if (propsDef.properties.length > 0 || propsDef.rootProperty) {\n        ref.definitions.push(propsDef);\n    }\n\n    return ref;\n}\n\nfunction resolveRootSchema(output: JsonSchemaOutput): any | null {\n    const rootRef = output.schemas?.[0];\n    if (!rootRef) return null;\n\n    if ('$ref' in rootRef && rootRef.$ref) {\n        const refPath = rootRef.$ref.replace('#/components/schemas/', '');\n        return output.components?.schemas?.[refPath] || null;\n    }\n\n    return rootRef;\n}\n\n/**\n * Recursively inlines all $ref pointers so the schema is self-contained\n * for xyd-openapi's converter (which warns on unresolved $ref).\n */\nfunction inlineRefs(schema: any, schemas: Record<string, any>, visited = new Set<string>()): any {\n    if (!schema || typeof schema !== 'object') return schema;\n\n    if (schema.$ref) {\n        const refPath = schema.$ref.replace('#/components/schemas/', '');\n        if (visited.has(refPath)) {\n            return {type: 'object', description: `(circular: ${refPath})`};\n        }\n        const resolved = schemas[refPath];\n        if (!resolved) return schema;\n        visited.add(refPath);\n        const result = inlineRefs({...resolved}, schemas, visited);\n        visited.delete(refPath);\n        return result;\n    }\n\n    if (Array.isArray(schema)) {\n        return schema.map((item) => inlineRefs(item, schemas, visited));\n    }\n\n    const result: any = {};\n    for (const [key, value] of Object.entries(schema)) {\n        result[key] = inlineRefs(value, schemas, visited);\n    }\n    return result;\n}\n"],"mappings":"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","names":["result"]}

package/dist/index.d.ts

@@ -0,0 +1,53 @@
+import { Plugin } from 'vite';
+import { Reference } from '@xyd-js/uniform';
+
+/**
+ * JSON Schema structure as produced by typia.json.schemas<[T]>().
+ */
+interface JsonSchemaOutput {
+    version?: string;
+    components?: {
+        schemas?: Record<string, any>;
+    };
+    schemas?: Array<{
+        $ref?: string;
+    } | any>;
+}
+/**
+ * Converts a typia JSON Schema output into an xyd uniform Reference,
+ * reusing xyd-openapi's battle-tested schema → uniform converter.
+ */
+declare function jsonSchemaToUniformReference(componentName: string, schema: JsonSchemaOutput): Reference;
+
+interface XydSourceReactRuntimeOptions {
+    /** Path to tsconfig.json. Required for typia's TypeScript transform. */
+    tsconfig?: string;
+    /** Property name for the injected uniform data. Defaults to `__xydUniform`. */
+    propertyName?: string;
+}
+/**
+ * Vite plugin that auto-detects React components, uses typia to generate
+ * JSON Schema from their props at build time, and injects `__xydUniform`.
+ *
+ * No manual annotations needed — the plugin:
+ * 1. Scans source files for exported functions with typed props
+ * 2. Injects `typia.json.schemas<[PropsType]>()` calls
+ * 3. Runs typia's TS transform to resolve all types (cross-file, generics, etc.)
+ * 4. Converts JSON Schema → xyd uniform format
+ * 5. Injects `Component.__xydUniform = JSON.parse('...')`
+ *
+ * ```ts
+ * import react from '@vitejs/plugin-react';
+ * import { xydSourceReactRuntime } from '@xyd-js/source-react-runtime';
+ *
+ * export default defineConfig({
+ *   plugins: [
+ *     xydSourceReactRuntime({ tsconfig: './tsconfig.json' }),
+ *     react(),
+ *   ],
+ * });
+ * ```
+ */
+declare function xydSourceReactRuntime(options?: XydSourceReactRuntimeOptions): Plugin;
+
+export { type XydSourceReactRuntimeOptions, jsonSchemaToUniformReference, xydSourceReactRuntime };