@lorion-org/react 1.0.0-beta.1 → 1.0.0-beta.3

package/dist/vite.js

@@ -1,19 +1,39 @@
 // src/vite.ts
 import { existsSync, readFileSync } from "fs";
-import { dirname, join, relative, resolve, sep } from "path";
-import {
-  createCompositionSelection,
-  createDescriptorCatalog
-} from "@lorion-org/composition-graph";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "path";
+import process from "process";
+import { loadEnv } from "vite";
 import {
   descriptorSchema,
-  discoverDescriptors
+  discoverDescriptors,
+  requirePackageName
 } from "@lorion-org/descriptor-discovery";
+import { resolveDescriptorSelection, selectDescriptors } from "@lorion-org/descriptor-selection";
+import {
+  createRuntimeConfigValidatorRegistry,
+  projectRuntimeConfigNamespaces,
+  resolveRuntimeConfigValidationMode,
+  toRuntimeConfigFragment,
+  toSnakeUpperCase
+} from "@lorion-org/runtime-config";
+import {
+  loadRuntimeConfigSourceTree,
+  readJsonFile,
+  resolveRuntimeConfigSource as resolveRuntimeConfigVarDirSource
+} from "@lorion-org/runtime-config-node";
+import { capabilitySpecifier } from "@lorion-org/surface-activation";
 var virtualModuleId = "virtual:capabilities";
 var resolvedVirtualModuleId = `\0${virtualModuleId}`;
+var runtimeConfigModuleId = "virtual:capability-runtime-config";
+var resolvedRuntimeConfigModuleId = `\0${runtimeConfigModuleId}`;
+var serverRuntimeConfigModuleId = "virtual:capability-runtime-config/server";
+var resolvedServerRuntimeConfigModuleId = `\0${serverRuntimeConfigModuleId}`;
+var defaultRuntimeConfigFileName = "capability.runtime.json";
+var defaultRuntimeConfigSchemaFileName = "capability.schema.json";
 function capabilityLoader(options = {}) {
   let config;
   let capabilities = [];
+  let runtimeConfig = { private: {}, public: {} };
   return {
     name: "lorion-react-capability-loader",
     enforce: "pre",
@@ -23,62 +43,132 @@ function capabilityLoader(options = {}) {
         resolveWorkspaceRoot(config.root, options),
         options
       );
+      runtimeConfig = createReactRuntimeConfig(
+        capabilities,
+        resolveWorkspaceRoot(config.root, options),
+        options.runtimeConfig,
+        config
+      );
     },
     resolveId(id) {
       if (id === virtualModuleId) return resolvedVirtualModuleId;
+      if (id === runtimeConfigModuleId) return resolvedRuntimeConfigModuleId;
+      if (id === serverRuntimeConfigModuleId) return resolvedServerRuntimeConfigModuleId;
       return capabilities.find((capability) => capability.importSpecifier === id)?.entryFile;
     },
-    load(id) {
+    load(id, loadOptions) {
+      if (id === resolvedRuntimeConfigModuleId) return renderRuntimeConfigModule(runtimeConfig);
+      if (id === resolvedServerRuntimeConfigModuleId) {
+        if (!loadOptions?.ssr) {
+          throw new Error(
+            "virtual:capability-runtime-config/server may only be imported from SSR/server code."
+          );
+        }
+        return renderServerRuntimeConfigModule(runtimeConfig);
+      }
       if (id !== resolvedVirtualModuleId) return null;
-      return renderCapabilityModule(capabilities);
+      return renderCapabilityModule(capabilities, resolveSelectionSeed(options));
     }
   };
 }
+function createReactRuntimeConfig(capabilities, workspaceRoot, options = {}, viteConfig = {}) {
+  const normalizedOptions = normalizeRuntimeConfigOptions(options);
+  if (!normalizedOptions.enabled) return { private: {}, public: {} };
+  const runtimeEnv = resolveRuntimeConfigEnv(viteConfig, normalizedOptions.env ?? {});
+  const sourceFragments = normalizedOptions.source ? loadRuntimeConfigSourceTree(
+    resolveRuntimeConfigPatternSource(workspaceRoot, normalizedOptions, runtimeEnv)
+  ) : /* @__PURE__ */ new Map();
+  const schemaEntries = readRuntimeConfigSchemas(capabilities, normalizedOptions.schemaFileName);
+  const envFragments = normalizedOptions.env === false ? /* @__PURE__ */ new Map() : createRuntimeConfigEnvFragments(
+    createRuntimeConfigEnvFragmentOptions(
+      capabilities,
+      schemaEntries.schemas,
+      runtimeEnv,
+      normalizedOptions.env
+    )
+  );
+  const fragments = mergeRuntimeConfigFragmentMaps(sourceFragments, envFragments);
+  validateReactRuntimeConfig(capabilities, fragments, schemaEntries, normalizedOptions.validation);
+  const projected = projectRuntimeConfigNamespaces(fragments, {
+    namespaceStrategy: "nested",
+    scopeIds: capabilities.map((capability) => capability.id)
+  });
+  const { public: publicConfig, ...privateConfig } = projected;
+  return {
+    public: publicConfig,
+    private: privateConfig
+  };
+}
 function lorionReact(options) {
   return {
     capabilityLoader: capabilityLoader(options),
     routeConfig: createCapabilityRouteConfig(options)
   };
 }
+function toResolveActivation(options) {
+  if (options.surface) {
+    if (options.activation) {
+      throw new Error("capabilityLoader: pass either `surface` or `activation`, not both.");
+    }
+    const { name, resolver } = options.surface;
+    return ({ capabilityDir, descriptor }) => resolver(name, { directory: capabilityDir, id: descriptor.id });
+  }
+  return options.activation;
+}
 function discoverCapabilities(workspaceRoot, options = {}) {
   const capabilitiesRoot = resolve(workspaceRoot, options.capabilitiesDir ?? "capabilities");
   if (!existsSync(capabilitiesRoot)) {
     throw new Error(`Capabilities directory not found: ${capabilitiesRoot}`);
   }
-  return discoverCapabilityDescriptors(workspaceRoot, options).map(discoverCapability).sort((left, right) => left.id.localeCompare(right.id));
+  const resolveActivation = toResolveActivation(options);
+  return discoverCapabilityDescriptors(workspaceRoot, options).map((entry) => discoverCapability(entry, resolveActivation)).sort((left, right) => left.id.localeCompare(right.id));
 }
 function discoverSelectedCapabilities(workspaceRoot, options = {}) {
   return selectCapabilities(discoverCapabilities(workspaceRoot, options), options);
 }
 function selectCapabilities(capabilities, options = {}) {
-  const enabledCapabilities = capabilities.filter((capability) => capability.disabled !== true);
-  if (!options.selected?.length && !options.baseDescriptors?.length) {
-    return [...enabledCapabilities];
-  }
-  const catalog = createDescriptorCatalog({
-    descriptors: enabledCapabilities.map((capability) => capability.manifest)
-  });
-  const selection = createCompositionSelection({
-    catalog,
-    selected: [...options.selected ?? []],
-    baseDescriptors: [...options.baseDescriptors ?? []],
+  return selectDescriptors({
+    items: capabilities,
+    getDescriptor: (capability) => capability.manifest,
+    withDescriptor: (capability, manifest) => ({ ...capability, manifest }),
+    seed: options,
+    ...options.relationDescriptors ? { relationDescriptors: options.relationDescriptors } : {},
     ...options.policy ? { policy: options.policy } : {}
   });
-  const selectedIds = new Set(selection.getResolved());
-  return enabledCapabilities.filter((capability) => selectedIds.has(capability.id));
 }
-function renderCapabilityModule(capabilities) {
-  const imports = capabilities.map(
-    (capability) => `import { capability as ${capability.variableName} } from '${capability.importSpecifier}'`
+function resolveSelectionSeed(options) {
+  return resolveDescriptorSelection(options);
+}
+function renderCapabilityModule(capabilities, selected = []) {
+  const activated = capabilities.filter(
+    (capability) => capability.exportName && capability.importSpecifier
+  );
+  const imports = activated.map(
+    (capability) => `import { ${capability.exportName} as ${capability.variableName} } from '${capability.importSpecifier}'`
   ).join("\n");
-  const variables = capabilities.map((capability) => `  ${capability.variableName},`).join("\n");
+  const variables = activated.map((capability) => `  ${capability.variableName},`).join("\n");
+  const capabilityIds = capabilities.map((capability) => capability.id);
   return `${imports}
 
+export const selectedCapabilityIds = ${JSON.stringify([...selected])}
+
+export const resolvedCapabilityIds = ${JSON.stringify(capabilityIds)}
+
 export const capabilityModules = [
 ${variables}
 ]
 `;
 }
+function renderRuntimeConfigModule(runtimeConfig) {
+  return `export const capabilityRuntimeConfig = ${JSON.stringify({ public: runtimeConfig.public })}
+
+export const publicCapabilityRuntimeConfig = capabilityRuntimeConfig.public
+`;
+}
+function renderServerRuntimeConfigModule(runtimeConfig) {
+  return `export const capabilityServerRuntimeConfig = ${JSON.stringify(runtimeConfig)}
+`;
+}
 function createCapabilityRouteConfig(options) {
   if (!options?.workspaceRoot) {
     throw new Error("createCapabilityRouteConfig requires a workspaceRoot option.");
@@ -117,7 +207,7 @@ function discoverCapabilityDescriptors(workspaceRoot, options) {
     }
   });
 }
-function discoverCapability(entry) {
+function discoverCapability(entry, resolveActivation) {
   const capabilityDir = entry.cwd;
   const packagePath = resolve(capabilityDir, "package.json");
   if (!existsSync(packagePath)) {
@@ -126,42 +216,235 @@ function discoverCapability(entry) {
     );
   }
   const packageJson = readJson(packagePath);
-  const packageName = packageJson.name;
-  if (typeof packageName !== "string") {
-    throw new Error(`Capability package is missing "name": ${packagePath}`);
-  }
-  const activationEntry = resolveActivationEntry(capabilityDir, packageJson);
+  const packageName = requirePackageName(packageJson, packagePath);
+  const activationEntry = resolveActivationEntry(
+    capabilityDir,
+    packageJson,
+    packageName,
+    entry.descriptor,
+    resolveActivation
+  );
   const routesDirectory = resolveRouteDirectory(capabilityDir);
   return {
+    capabilityDir,
     id: entry.descriptor.id,
     disabled: entry.descriptor.disabled === true,
-    entryFile: activationEntry.entryFile,
-    importSpecifier: activationEntry.importSpecifier,
     manifest: entry.descriptor,
     packageName,
+    ...activationEntry ? {
+      exportName: activationEntry.exportName,
+      importSpecifier: activationEntry.importSpecifier,
+      ...activationEntry.entryFile ? { entryFile: activationEntry.entryFile } : {}
+    } : {},
     ...routesDirectory ? { routesDirectory } : {},
     variableName: toVariableName(entry.descriptor.id)
   };
 }
-function resolveRouteDirectory(capabilityDir) {
-  const routesDirectory = resolve(capabilityDir, "src", "routes");
-  return existsSync(routesDirectory) ? routesDirectory : void 0;
+function normalizeRuntimeConfigOptions(options) {
+  if (options === false) {
+    return {
+      configFileName: defaultRuntimeConfigFileName,
+      enabled: false,
+      env: false,
+      schemaFileName: defaultRuntimeConfigSchemaFileName,
+      validation: false
+    };
+  }
+  const configFileName = options.configFileName ?? defaultRuntimeConfigFileName;
+  return {
+    configFileName,
+    enabled: options.enabled !== false,
+    env: options.env ?? {},
+    schemaFileName: options.schemaFileName ?? defaultRuntimeConfigSchemaFileName,
+    ...options.source === false ? {} : {
+      source: options.source ?? { paths: [] }
+    },
+    validation: options.validation === false ? false : options.validation ?? {},
+    ...options.varDir ? { varDir: options.varDir } : {}
+  };
 }
-function resolveActivationEntry(capabilityDir, packageJson) {
-  const packageName = packageJson.name;
-  const packageExports = packageJson.exports;
-  if (typeof packageName !== "string") {
-    throw new Error(
-      `Capability package is missing "name": ${resolve(capabilityDir, "package.json")}`
-    );
+function resolveRuntimeConfigPatternSource(workspaceRoot, options, env) {
+  if (!options.source?.paths.length) {
+    const varDir = resolveRuntimeConfigVarDir(workspaceRoot, options.varDir, env);
+    return {
+      paths: [join(varDir, "runtime-config", "*", options.configFileName)]
+    };
   }
-  if (!isRecord(packageExports) || typeof packageExports["./capability"] !== "string") {
-    throw new Error(`Capability package is missing a "./capability" export: ${capabilityDir}`);
+  return {
+    paths: options.source.paths.map(
+      (entry) => isAbsolute(entry) ? entry : resolve(workspaceRoot, entry)
+    )
+  };
+}
+function resolveRuntimeConfigVarDir(workspaceRoot, options, env) {
+  const rawVarDir = typeof options === "string" ? options : resolveRuntimeConfigVarDirSource({
+    defaultVarDir: resolve(workspaceRoot, ".data"),
+    env: options?.env ?? env,
+    envKey: options?.envKey ?? "RUNTIME_CONFIG_VAR_DIR",
+    ...options?.value ? { varDir: options.value } : {},
+    ...options?.defaultValue ? { defaultVarDir: options.defaultValue } : {}
+  }).varDir;
+  return isAbsolute(rawVarDir) ? rawVarDir : resolve(workspaceRoot, rawVarDir);
+}
+function resolveRuntimeConfigEnv(viteConfig, options) {
+  if (options === false) return {};
+  if (options.env) return options.env;
+  const mode = viteConfig.mode ?? process.env.NODE_ENV ?? "development";
+  const envDir = typeof viteConfig.envDir === "string" ? viteConfig.envDir : viteConfig.root ?? process.cwd();
+  return {
+    ...loadEnv(mode, envDir, ""),
+    ...process.env,
+    ...viteConfig.env ?? {}
+  };
+}
+function readRuntimeConfigSchemas(capabilities, schemaFileName) {
+  const paths = /* @__PURE__ */ new Map();
+  const schemas = {};
+  for (const capability of capabilities) {
+    const schemaPath = resolve(capability.capabilityDir, schemaFileName);
+    const schema = readJsonFile(schemaPath, {
+      onParseError: (error, filePath) => {
+        throw new Error(`RuntimeConfig schema JSON parse error in "${filePath}": ${String(error)}`);
+      }
+    });
+    if (!schema) continue;
+    paths.set(capability.id, schemaPath);
+    schemas[capability.id] = schema;
+  }
+  return { paths, schemas };
+}
+function isJsonSchemaObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getRuntimeConfigSchemaSectionKeys(schema, visibility) {
+  if (!isJsonSchemaObject(schema)) return [];
+  const section = schema.properties?.[visibility];
+  if (!isJsonSchemaObject(section) || !isJsonSchemaObject(section.properties)) return [];
+  return Object.keys(section.properties).sort();
+}
+function createRuntimeConfigEnvKey(input) {
+  return toSnakeUpperCase([input.prefix, input.scopeId, input.key].filter(Boolean).join("_"));
+}
+function createRuntimeConfigEnvFragments(input) {
+  const fragments = /* @__PURE__ */ new Map();
+  for (const capability of input.capabilities) {
+    const schema = input.schemas[capability.id];
+    const publicConfig = {};
+    const privateConfig = {};
+    for (const key of getRuntimeConfigSchemaSectionKeys(schema, "public")) {
+      const envKey = createRuntimeConfigEnvKey({
+        key,
+        prefix: input.publicPrefix ?? "VITE",
+        scopeId: capability.id
+      });
+      const value = input.env[envKey];
+      if (value !== void 0) publicConfig[key] = value;
+    }
+    for (const key of getRuntimeConfigSchemaSectionKeys(schema, "private")) {
+      const envKey = createRuntimeConfigEnvKey({
+        key,
+        scopeId: capability.id,
+        ...input.privatePrefix !== void 0 ? { prefix: input.privatePrefix } : {}
+      });
+      const value = input.env[envKey];
+      if (value !== void 0) privateConfig[key] = value;
+    }
+    if (Object.keys(publicConfig).length || Object.keys(privateConfig).length) {
+      fragments.set(capability.id, {
+        ...Object.keys(publicConfig).length ? { public: publicConfig } : {},
+        ...Object.keys(privateConfig).length ? { private: privateConfig } : {}
+      });
+    }
   }
+  return fragments;
+}
+function createRuntimeConfigEnvFragmentOptions(capabilities, schemas, env, options) {
   return {
-    entryFile: resolve(capabilityDir, packageExports["./capability"]),
-    importSpecifier: `${packageName}/capability`
+    capabilities,
+    env,
+    ...options.privatePrefix !== void 0 ? { privatePrefix: options.privatePrefix } : {},
+    ...options.publicPrefix !== void 0 ? { publicPrefix: options.publicPrefix } : {},
+    schemas
+  };
+}
+function mergeRuntimeConfigSections(left, right) {
+  const section = {
+    ...left ?? {},
+    ...right ?? {}
   };
+  return Object.keys(section).length ? section : void 0;
+}
+function mergeRuntimeConfigFragment(left, right) {
+  const publicConfig = mergeRuntimeConfigSections(left?.public, right?.public);
+  const privateConfig = mergeRuntimeConfigSections(left?.private, right?.private);
+  return toRuntimeConfigFragment({
+    ...publicConfig ? { public: publicConfig } : {},
+    ...privateConfig ? { private: privateConfig } : {}
+  });
+}
+function mergeRuntimeConfigFragmentMaps(left, right) {
+  const fragments = new Map(left);
+  for (const [scopeId, config] of right.entries()) {
+    fragments.set(scopeId, mergeRuntimeConfigFragment(fragments.get(scopeId), config));
+  }
+  return fragments;
+}
+function getCapabilityRuntimeConfigPolicy(capability, validation) {
+  return capability.manifest.runtimeConfig ?? validation.policy ?? "optional";
+}
+function shouldValidateRuntimeConfigFragment(input) {
+  if (!input.schema) return false;
+  const mode = resolveRuntimeConfigValidationMode(
+    getCapabilityRuntimeConfigPolicy(input.capability, input.validation)
+  );
+  if (mode === "none" || mode === "onUse") return false;
+  if (mode === "startup") return true;
+  return Boolean(input.fragment);
+}
+function validateReactRuntimeConfig(capabilities, fragments, schemas, validation) {
+  if (validation === false) return;
+  const registry = createRuntimeConfigValidatorRegistry(schemas.schemas, {
+    ...validation.formatError ? {
+      formatError: (target, validationError) => validation.formatError(
+        {
+          configPath: `${target.scopeId} runtime config`,
+          schemaPath: schemas.paths.get(target.scopeId) ?? "",
+          scopeId: target.scopeId
+        },
+        validationError
+      )
+    } : {}
+  });
+  for (const capability of capabilities) {
+    const fragment = fragments.get(capability.id);
+    const schema = schemas.schemas[capability.id];
+    if (!shouldValidateRuntimeConfigFragment({ capability, fragment, schema, validation })) {
+      continue;
+    }
+    registry.assert(capability.id, fragment ?? {});
+  }
+}
+function resolveRouteDirectory(capabilityDir) {
+  const routesDirectory = resolve(capabilityDir, "src", "routes");
+  return existsSync(routesDirectory) ? routesDirectory : void 0;
+}
+function resolveActivationEntry(capabilityDir, packageJson, packageName, descriptor, resolveActivation) {
+  if (!resolveActivation) {
+    const packageExports = packageJson.exports;
+    if (!isRecord(packageExports) || typeof packageExports["./capability"] !== "string") {
+      throw new Error(`Capability package is missing a "./capability" export: ${capabilityDir}`);
+    }
+    return {
+      entryFile: resolve(capabilityDir, packageExports["./capability"]),
+      exportName: "capability",
+      importSpecifier: capabilitySpecifier(packageName, "./capability")
+    };
+  }
+  const activation = resolveActivation({ capabilityDir, descriptor, packageJson, packageName });
+  if (!activation) return null;
+  const exportName = activation.exportName ?? "capability";
+  const exportSubpath = activation.exportSubpath ?? "./capability";
+  return { exportName, importSpecifier: capabilitySpecifier(packageName, exportSubpath) };
 }
 function hasRouteDirectory(capability) {
   return typeof capability.routesDirectory === "string";
@@ -198,8 +481,11 @@ function toPosixPath(path) {
 export {
   capabilityLoader,
   createCapabilityRouteConfig,
+  createReactRuntimeConfig,
   discoverCapabilities,
   discoverSelectedCapabilities,
   lorionReact,
-  renderCapabilityModule
+  renderCapabilityModule,
+  renderRuntimeConfigModule,
+  renderServerRuntimeConfigModule
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lorion-org/react",
-  "version": "1.0.0-beta.1",
+  "version": "1.0.0-beta.3",
   "description": "React capability runtime and Vite helpers for LORION descriptor-based applications.",
   "license": "MIT",
   "repository": {
@@ -22,6 +22,10 @@
   },
   "exports": {
     ".": {
+      "lorion-source": {
+        "types": "./src/index.ts",
+        "default": "./src/index.ts"
+      },
       "import": {
         "types": "./dist/index.d.ts",
         "default": "./dist/index.js"
@@ -32,6 +36,10 @@
       }
     },
     "./vite": {
+      "lorion-source": {
+        "types": "./src/vite.ts",
+        "default": "./src/vite.ts"
+      },
       "import": {
         "types": "./dist/vite.d.ts",
         "default": "./dist/vite.js"
@@ -44,15 +52,27 @@
   },
   "files": [
     "dist",
-    "LICENSE"
+    "LICENSE",
+    "src/**/*.ts",
+    "!src/**/*.spec.ts"
   ],
   "dependencies": {
-    "@lorion-org/composition-graph": "^1.0.0-beta.1",
-    "@lorion-org/provider-selection": "^1.0.0-beta.1",
-    "@lorion-org/descriptor-discovery": "^1.0.0-beta.1"
+    "@lorion-org/composition-graph": "^1.0.0-beta.2",
+    "@lorion-org/descriptor-discovery": "^1.0.0-beta.3",
+    "@lorion-org/descriptor-selection": "^1.0.0-beta.3",
+    "@lorion-org/provider-selection": "^1.0.0-beta.2",
+    "@lorion-org/runtime-config": "^1.0.0-beta.1",
+    "@lorion-org/runtime-config-node": "^1.0.0-beta.1",
+    "@lorion-org/surface-activation": "^1.0.0-beta.3"
   },
   "peerDependencies": {
-    "react": "^19.0.0"
+    "react": "^19.0.0",
+    "vite": "^7.0.0"
+  },
+  "peerDependenciesMeta": {
+    "vite": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@tanstack/react-router": "^1.168.25",
@@ -80,10 +100,7 @@
     "clean": "rimraf coverage dist tsconfig.tsbuildinfo",
     "lint": "eslint src --ext .ts",
     "package:check": "pnpm build && pnpm pack --dry-run && publint",
-    "build:playground": "vite build --config playground/vite.config.ts",
-    "dev:playground": "vite dev --config playground/vite.config.ts --host 0.0.0.0",
     "test": "vitest run --root ../.. --config vitest.config.mts packages/react/src/index.spec.ts packages/react/src/vite.spec.ts",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "typecheck:playground": "tsc -p playground/tsconfig.json --noEmit"
+    "typecheck": "tsc -p tsconfig.json --noEmit"
   }
 }