@lorion-org/nuxt 1.0.0-beta.0

package/dist/runtime-config-node.d.ts

@@ -0,0 +1,15 @@
+import { ValidateRuntimeConfigPatternSourceScopesOptions, RuntimeConfigSchemaTargetInput, RuntimeConfigValidateResult } from '@lorion-org/runtime-config-node';
+import { RuntimeConfigFragmentMap } from '@lorion-org/runtime-config';
+import { C as CreateNuxtRuntimeConfigOptions, n as RuntimeConfigNuxtSourceOptions, a as NuxtRuntimeConfig } from './extensions-vNob6d2x.js';
+import '@lorion-org/composition-graph';
+import '@lorion-org/provider-selection';
+import '@lorion-org/descriptor-discovery';
+
+type CreateNuxtRuntimeConfigFromSourceOptions = Omit<CreateNuxtRuntimeConfigOptions, 'fragments' | 'runtimeConfig'>;
+type ValidateNuxtRuntimeConfigSourceScopesOptions = Omit<ValidateRuntimeConfigPatternSourceScopesOptions, 'fileName' | 'runtimeConfigDirName'>;
+declare function resolveNuxtRuntimeConfigPublicRootPath(source: RuntimeConfigNuxtSourceOptions): string | undefined;
+declare function loadNuxtRuntimeConfigFragments(source: RuntimeConfigNuxtSourceOptions, options?: Pick<CreateNuxtRuntimeConfigOptions, 'contextInputKey'>): RuntimeConfigFragmentMap;
+declare function createNuxtRuntimeConfigFromSource(source: RuntimeConfigNuxtSourceOptions, options?: CreateNuxtRuntimeConfigFromSourceOptions): NuxtRuntimeConfig;
+declare function validateNuxtRuntimeConfigSourceScopes(source: RuntimeConfigNuxtSourceOptions, targets: RuntimeConfigSchemaTargetInput[], options?: ValidateNuxtRuntimeConfigSourceScopesOptions): RuntimeConfigValidateResult;
+
+export { type CreateNuxtRuntimeConfigFromSourceOptions, RuntimeConfigNuxtSourceOptions, type ValidateNuxtRuntimeConfigSourceScopesOptions, createNuxtRuntimeConfigFromSource, loadNuxtRuntimeConfigFragments, resolveNuxtRuntimeConfigPublicRootPath, validateNuxtRuntimeConfigSourceScopes };

package/dist/runtime-config-node.js

@@ -0,0 +1,106 @@
+// src/runtime-config-node.ts
+import {
+  loadRuntimeConfigSourceTree,
+  resolveRuntimeConfigSourcePublicRootPath,
+  validateRuntimeConfigSourceScopes
+} from "@lorion-org/runtime-config-node";
+import { toRuntimeConfigFragment as toRuntimeConfigFragment2 } from "@lorion-org/runtime-config";
+
+// src/runtime-config.ts
+import {
+  getPrivateRuntimeConfigScope,
+  getPublicRuntimeConfigScope,
+  getRuntimeConfigFragment,
+  getRuntimeConfigScope,
+  projectSectionedRuntimeConfig,
+  resolveRuntimeConfigValueFromRuntimeConfig,
+  toRuntimeConfigFragment
+} from "@lorion-org/runtime-config";
+function createContextInputOptions(contextInputKey) {
+  return contextInputKey === void 0 ? {} : { contextInputKey };
+}
+function createPrivateOutputOptions(privateOutput) {
+  return privateOutput === void 0 ? {} : { privateOutput };
+}
+function normalizeNuxtRuntimeConfigFragments(fragments = {}, options = {}) {
+  if (fragments instanceof Map) {
+    const normalizedFragments = /* @__PURE__ */ new Map();
+    for (const [scopeId, config] of fragments.entries()) {
+      normalizedFragments.set(scopeId, toRuntimeConfigFragment(config, options));
+    }
+    return normalizedFragments;
+  }
+  if (Array.isArray(fragments)) {
+    return fragments.map((fragment) => ({
+      scopeId: fragment.scopeId,
+      config: toRuntimeConfigFragment(fragment.config, options)
+    }));
+  }
+  return Object.entries(fragments).map(([scopeId, config]) => ({
+    scopeId,
+    config: toRuntimeConfigFragment(config, options)
+  }));
+}
+function toNuxtRuntimeConfig(runtimeConfig, options = {}) {
+  if (options.privateOutput === "section") {
+    return {
+      private: {
+        ...runtimeConfig.private
+      },
+      public: {
+        ...runtimeConfig.public
+      }
+    };
+  }
+  return {
+    ...runtimeConfig.private,
+    public: {
+      ...runtimeConfig.public
+    }
+  };
+}
+function createNuxtRuntimeConfig(options = {}) {
+  const { contextInputKey, fragments, runtimeConfig, ...projectOptions } = options;
+  const runtimeConfigFragments = fragments ?? {};
+  const sectionedRuntimeConfig = runtimeConfig ?? projectSectionedRuntimeConfig(
+    normalizeNuxtRuntimeConfigFragments(
+      runtimeConfigFragments,
+      createContextInputOptions(contextInputKey)
+    ),
+    projectOptions
+  );
+  return toNuxtRuntimeConfig(
+    sectionedRuntimeConfig,
+    createPrivateOutputOptions(options.privateOutput)
+  );
+}
+
+// src/runtime-config-node.ts
+function resolveNuxtRuntimeConfigPublicRootPath(source) {
+  return resolveRuntimeConfigSourcePublicRootPath(source);
+}
+function loadNuxtRuntimeConfigFragments(source, options = {}) {
+  const fragments = loadRuntimeConfigSourceTree(source);
+  const normalizedFragments = /* @__PURE__ */ new Map();
+  for (const [scopeId, config] of fragments.entries()) {
+    normalizedFragments.set(scopeId, toRuntimeConfigFragment2(config, options));
+  }
+  return normalizedFragments;
+}
+function createNuxtRuntimeConfigFromSource(source, options = {}) {
+  return createNuxtRuntimeConfig({
+    ...options,
+    fragments: loadNuxtRuntimeConfigFragments(source, {
+      ...options.contextInputKey ? { contextInputKey: options.contextInputKey } : {}
+    })
+  });
+}
+function validateNuxtRuntimeConfigSourceScopes(source, targets, options = {}) {
+  return validateRuntimeConfigSourceScopes(source, targets, options);
+}
+export {
+  createNuxtRuntimeConfigFromSource,
+  loadNuxtRuntimeConfigFragments,
+  resolveNuxtRuntimeConfigPublicRootPath,
+  validateNuxtRuntimeConfigSourceScopes
+};

package/dist/runtime-config.d.ts

@@ -0,0 +1,22 @@
+import { SectionedRuntimeConfig, GetRuntimeConfigFragmentOptions, RuntimeConfigContext, RuntimeConfigSection, GetRuntimeConfigScopeOptions, NamedRuntimeConfigFragment, RuntimeConfigFragmentMap, ResolveRuntimeConfigValueFromRuntimeConfigOptions } from '@lorion-org/runtime-config';
+import { C as CreateNuxtRuntimeConfigOptions, a as NuxtRuntimeConfig, o as NuxtRuntimeConfigInput, p as ReadNuxtRuntimeConfigOptions, q as NuxtExtensionSelection, j as NuxtProviderSelectionRuntimeConfig, s as RuntimeConfigNuxtFragments } from './extensions-vNob6d2x.js';
+export { t as NuxtExtensionSelectionRuntimeConfig, u as NuxtPrivateRuntimeConfigMode } from './extensions-vNob6d2x.js';
+import '@lorion-org/composition-graph';
+import '@lorion-org/provider-selection';
+import '@lorion-org/descriptor-discovery';
+import '@lorion-org/runtime-config-node';
+
+declare function normalizeNuxtRuntimeConfigFragments(fragments?: RuntimeConfigNuxtFragments, options?: Pick<CreateNuxtRuntimeConfigOptions, 'contextInputKey'>): NamedRuntimeConfigFragment[] | RuntimeConfigFragmentMap;
+declare function toNuxtRuntimeConfig(runtimeConfig: SectionedRuntimeConfig, options?: Pick<CreateNuxtRuntimeConfigOptions, 'privateOutput'>): NuxtRuntimeConfig;
+declare function fromNuxtRuntimeConfig(runtimeConfig: NuxtRuntimeConfigInput, options?: ReadNuxtRuntimeConfigOptions): SectionedRuntimeConfig;
+declare function createNuxtRuntimeConfig(options?: CreateNuxtRuntimeConfigOptions): NuxtRuntimeConfig;
+declare function mergeNuxtRuntimeConfig(target?: NuxtRuntimeConfigInput, source?: NuxtRuntimeConfigInput): NuxtRuntimeConfig;
+declare function getNuxtExtensionSelection(runtimeConfig: NuxtRuntimeConfigInput): NuxtExtensionSelection;
+declare function getNuxtProviderSelection(runtimeConfig: NuxtRuntimeConfigInput): NuxtProviderSelectionRuntimeConfig | undefined;
+declare function getPublicNuxtRuntimeConfigScope<T extends RuntimeConfigSection = RuntimeConfigSection>(runtimeConfig: NuxtRuntimeConfigInput, scopeId: string, options?: Omit<GetRuntimeConfigScopeOptions, 'visibility'> & ReadNuxtRuntimeConfigOptions): T;
+declare function getNuxtRuntimeConfigScope<T extends RuntimeConfigSection = RuntimeConfigSection>(runtimeConfig: NuxtRuntimeConfigInput, scopeId: string, options?: GetRuntimeConfigScopeOptions & ReadNuxtRuntimeConfigOptions): T;
+declare function getPrivateNuxtRuntimeConfigScope<T extends RuntimeConfigSection = RuntimeConfigSection>(runtimeConfig: NuxtRuntimeConfigInput, scopeId: string, options?: Omit<GetRuntimeConfigScopeOptions, 'visibility'> & ReadNuxtRuntimeConfigOptions): T;
+declare function resolveNuxtRuntimeConfigValue<T = unknown>(runtimeConfig: NuxtRuntimeConfigInput, scopeId: string, key: string, options?: ResolveRuntimeConfigValueFromRuntimeConfigOptions<T> & ReadNuxtRuntimeConfigOptions): T | undefined;
+declare function getNuxtRuntimeConfigFragment(runtimeConfig: NuxtRuntimeConfigInput, scopeId: string, options?: GetRuntimeConfigFragmentOptions & ReadNuxtRuntimeConfigOptions): RuntimeConfigContext;
+
+export { CreateNuxtRuntimeConfigOptions, NuxtExtensionSelection, NuxtRuntimeConfig, NuxtRuntimeConfigInput, ReadNuxtRuntimeConfigOptions, RuntimeConfigNuxtFragments, createNuxtRuntimeConfig, fromNuxtRuntimeConfig, getNuxtExtensionSelection, getNuxtProviderSelection, getNuxtRuntimeConfigFragment, getNuxtRuntimeConfigScope, getPrivateNuxtRuntimeConfigScope, getPublicNuxtRuntimeConfigScope, mergeNuxtRuntimeConfig, normalizeNuxtRuntimeConfigFragments, resolveNuxtRuntimeConfigValue, toNuxtRuntimeConfig };

package/dist/runtime-config.js

@@ -0,0 +1,184 @@
+// src/runtime-config.ts
+import {
+  getPrivateRuntimeConfigScope,
+  getPublicRuntimeConfigScope,
+  getRuntimeConfigFragment,
+  getRuntimeConfigScope,
+  projectSectionedRuntimeConfig,
+  resolveRuntimeConfigValueFromRuntimeConfig,
+  toRuntimeConfigFragment
+} from "@lorion-org/runtime-config";
+var isObject = (value) => {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+var toStringArray = (value) => Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+function createContextInputOptions(contextInputKey) {
+  return contextInputKey === void 0 ? {} : { contextInputKey };
+}
+function createPrivateOutputOptions(privateOutput) {
+  return privateOutput === void 0 ? {} : { privateOutput };
+}
+function createPrivateInputOptions(privateInput) {
+  return privateInput === void 0 ? {} : { privateInput };
+}
+function withoutPublicRuntimeConfig(config) {
+  const privateConfig = { ...config };
+  delete privateConfig.public;
+  return privateConfig;
+}
+function normalizeNuxtRuntimeConfigFragments(fragments = {}, options = {}) {
+  if (fragments instanceof Map) {
+    const normalizedFragments = /* @__PURE__ */ new Map();
+    for (const [scopeId, config] of fragments.entries()) {
+      normalizedFragments.set(scopeId, toRuntimeConfigFragment(config, options));
+    }
+    return normalizedFragments;
+  }
+  if (Array.isArray(fragments)) {
+    return fragments.map((fragment) => ({
+      scopeId: fragment.scopeId,
+      config: toRuntimeConfigFragment(fragment.config, options)
+    }));
+  }
+  return Object.entries(fragments).map(([scopeId, config]) => ({
+    scopeId,
+    config: toRuntimeConfigFragment(config, options)
+  }));
+}
+function toNuxtRuntimeConfig(runtimeConfig, options = {}) {
+  if (options.privateOutput === "section") {
+    return {
+      private: {
+        ...runtimeConfig.private
+      },
+      public: {
+        ...runtimeConfig.public
+      }
+    };
+  }
+  return {
+    ...runtimeConfig.private,
+    public: {
+      ...runtimeConfig.public
+    }
+  };
+}
+function fromNuxtRuntimeConfig(runtimeConfig, options = {}) {
+  if (options.privateInput === "section") {
+    return {
+      public: isObject(runtimeConfig.public) ? runtimeConfig.public : {},
+      private: isObject(runtimeConfig.private) ? runtimeConfig.private : {}
+    };
+  }
+  const { public: publicConfig = {}, ...privateConfig } = runtimeConfig;
+  return {
+    public: publicConfig,
+    private: privateConfig
+  };
+}
+function createNuxtRuntimeConfig(options = {}) {
+  const { contextInputKey, fragments, runtimeConfig, ...projectOptions } = options;
+  const runtimeConfigFragments = fragments ?? {};
+  const sectionedRuntimeConfig = runtimeConfig ?? projectSectionedRuntimeConfig(
+    normalizeNuxtRuntimeConfigFragments(
+      runtimeConfigFragments,
+      createContextInputOptions(contextInputKey)
+    ),
+    projectOptions
+  );
+  return toNuxtRuntimeConfig(
+    sectionedRuntimeConfig,
+    createPrivateOutputOptions(options.privateOutput)
+  );
+}
+function mergeNuxtRuntimeConfig(target = {}, source = {}) {
+  const targetPublic = isObject(target.public) ? target.public : {};
+  const sourcePublic = isObject(source.public) ? source.public : {};
+  return {
+    ...withoutPublicRuntimeConfig(target),
+    ...withoutPublicRuntimeConfig(source),
+    public: {
+      ...targetPublic,
+      ...sourcePublic
+    }
+  };
+}
+function getNuxtExtensionSelection(runtimeConfig) {
+  const selection = isObject(runtimeConfig.public?.extensionSelection) ? runtimeConfig.public.extensionSelection : void 0;
+  if (!selection) {
+    return {
+      discoveredExtensionIds: [],
+      notInjectedExtensionIds: [],
+      resolvedExtensionIds: [],
+      selectedExtensionIds: []
+    };
+  }
+  const discoveredExtensionIds = toStringArray(selection.discoveredExtensionIds);
+  const resolvedExtensionIds = toStringArray(selection.resolvedExtensionIds);
+  const resolvedExtensionIdSet = new Set(resolvedExtensionIds);
+  return {
+    discoveredExtensionIds,
+    notInjectedExtensionIds: discoveredExtensionIds.filter((id) => !resolvedExtensionIdSet.has(id)).sort((left, right) => left.localeCompare(right)),
+    resolvedExtensionIds,
+    selectedExtensionIds: toStringArray(selection.selectedExtensionIds)
+  };
+}
+function getNuxtProviderSelection(runtimeConfig) {
+  const providerSelection = runtimeConfig.public?.providerSelection;
+  return isObject(providerSelection) && isObject(providerSelection.selections) ? providerSelection : void 0;
+}
+function getPublicNuxtRuntimeConfigScope(runtimeConfig, scopeId, options = {}) {
+  const { privateInput, ...scopeOptions } = options;
+  return getPublicRuntimeConfigScope(
+    fromNuxtRuntimeConfig(runtimeConfig, createPrivateInputOptions(privateInput)),
+    scopeId,
+    scopeOptions
+  );
+}
+function getNuxtRuntimeConfigScope(runtimeConfig, scopeId, options = {}) {
+  const { privateInput, ...scopeOptions } = options;
+  return getRuntimeConfigScope(
+    fromNuxtRuntimeConfig(runtimeConfig, createPrivateInputOptions(privateInput)),
+    scopeId,
+    scopeOptions
+  );
+}
+function getPrivateNuxtRuntimeConfigScope(runtimeConfig, scopeId, options = {}) {
+  const { privateInput, ...scopeOptions } = options;
+  return getPrivateRuntimeConfigScope(
+    fromNuxtRuntimeConfig(runtimeConfig, createPrivateInputOptions(privateInput)),
+    scopeId,
+    scopeOptions
+  );
+}
+function resolveNuxtRuntimeConfigValue(runtimeConfig, scopeId, key, options = {}) {
+  const { privateInput, ...resolveOptions } = options;
+  return resolveRuntimeConfigValueFromRuntimeConfig(
+    fromNuxtRuntimeConfig(runtimeConfig, createPrivateInputOptions(privateInput)),
+    scopeId,
+    key,
+    resolveOptions
+  );
+}
+function getNuxtRuntimeConfigFragment(runtimeConfig, scopeId, options = {}) {
+  const { privateInput, ...fragmentOptions } = options;
+  return getRuntimeConfigFragment(
+    fromNuxtRuntimeConfig(runtimeConfig, createPrivateInputOptions(privateInput)),
+    scopeId,
+    fragmentOptions
+  );
+}
+export {
+  createNuxtRuntimeConfig,
+  fromNuxtRuntimeConfig,
+  getNuxtExtensionSelection,
+  getNuxtProviderSelection,
+  getNuxtRuntimeConfigFragment,
+  getNuxtRuntimeConfigScope,
+  getPrivateNuxtRuntimeConfigScope,
+  getPublicNuxtRuntimeConfigScope,
+  mergeNuxtRuntimeConfig,
+  normalizeNuxtRuntimeConfigFragments,
+  resolveNuxtRuntimeConfigValue,
+  toNuxtRuntimeConfig
+};

package/examples/read-runtime-config.server.ts

@@ -0,0 +1,3 @@
+export default defineEventHandler(() => {
+  return usePublicRuntimeConfigScope('billing');
+});

package/examples/runtime-config-source.nuxt.config.ts

@@ -0,0 +1,13 @@
+import { defineNuxtConfig } from 'nuxt/config';
+import type {} from '@lorion-org/nuxt';
+
+export default defineNuxtConfig({
+  modules: ['@lorion-org/nuxt'],
+  lorion: {
+    runtimeConfig: {
+      source: {
+        paths: ['.runtimeconfig/runtime-config/*/runtime.config.json'],
+      },
+    },
+  },
+});

package/examples/selected-extensions.nuxt.config.ts

@@ -0,0 +1,30 @@
+import { defineNuxtConfig } from 'nuxt/config';
+import LorionNuxtModule, {
+  createNuxtExtensionBootstrap,
+  createNuxtExtensionLayerPaths,
+} from '@lorion-org/nuxt';
+
+const extensionBootstrap = createNuxtExtensionBootstrap({
+  rootDir: __dirname,
+  options: {
+    defaultSelection: 'default',
+    descriptorPaths: ['extensions/*/extension.json'],
+  },
+});
+
+export default defineNuxtConfig({
+  extends: createNuxtExtensionLayerPaths(extensionBootstrap),
+  modules: [
+    [
+      LorionNuxtModule,
+      {
+        extensionBootstrap,
+        providers: {
+          configuredProviders: {
+            'payment-checkout': 'payment-provider-stripe',
+          },
+        },
+      },
+    ],
+  ],
+});

package/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "@lorion-org/nuxt",
+  "version": "1.0.0-beta.0",
+  "description": "Nuxt module for LORION libraries and framework adapters.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lorion-org/lorion.git",
+    "directory": "packages/nuxt"
+  },
+  "homepage": "https://github.com/lorion-org/lorion/tree/main/packages/nuxt#readme",
+  "bugs": {
+    "url": "https://github.com/lorion-org/lorion/issues"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./runtime-config": {
+      "types": "./dist/runtime-config.d.ts",
+      "import": "./dist/runtime-config.js",
+      "default": "./dist/runtime-config.js"
+    },
+    "./runtime-config-node": {
+      "types": "./dist/runtime-config-node.d.ts",
+      "import": "./dist/runtime-config-node.js",
+      "default": "./dist/runtime-config-node.js"
+    },
+    "./descriptor-schema": {
+      "types": "./dist/descriptor-schema.d.ts",
+      "import": "./dist/descriptor-schema.js",
+      "default": "./dist/descriptor-schema.js"
+    }
+  },
+  "files": [
+    "dist",
+    "examples",
+    "LICENSE"
+  ],
+  "keywords": [
+    "lorion",
+    "nuxt",
+    "module",
+    "runtime-config"
+  ],
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "dependencies": {
+    "@lorion-org/provider-selection": "^1.0.0-beta.0",
+    "@lorion-org/composition-graph": "^1.0.0-beta.0",
+    "@lorion-org/descriptor-discovery": "^1.0.0-beta.0",
+    "@lorion-org/runtime-config": "^1.0.0-beta.0",
+    "@lorion-org/runtime-config-node": "^1.0.0-beta.0"
+  },
+  "peerDependencies": {
+    "@nuxt/kit": "^4.0.0",
+    "nuxt": "^4.0.0"
+  },
+  "devDependencies": {
+    "@nuxt/kit": "^4.2.1",
+    "@nuxt/schema": "^4.4.2",
+    "@nuxt/test-utils": "^3.23.0",
+    "nuxt": "^4.4.2",
+    "@lorion-org/registry-hub": "^1.0.0-beta.0"
+  },
+  "scripts": {
+    "build": "rimraf dist && tsup src/index.ts src/runtime-config.ts src/runtime-config-node.ts src/descriptor-schema.ts --format esm --dts --splitting false",
+    "clean": "rimraf coverage dist tsconfig.tsbuildinfo",
+    "lint": "eslint src --ext .ts",
+    "package:check": "pnpm build && pnpm pack --dry-run && publint",
+    "test": "pnpm test:unit && pnpm test:e2e",
+    "test:unit": "vitest run --config test/vitest.unit.config.mts",
+    "test:e2e": "vitest run --config test/vitest.e2e.config.mts",
+    "build:playground": "nuxi build playground",
+    "dev:playground": "nuxi dev playground",
+    "typecheck:playground": "nuxi typecheck playground",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  }
+}