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

package/dist/extensions.js

@@ -0,0 +1,401 @@
+// src/extensions.ts
+import { existsSync } from "fs";
+import { join } from "path";
+import process from "process";
+import {
+  createDescriptorCatalog,
+  parseDescriptorIds,
+  resolveDescriptorSelectionSeed
+} from "@lorion-org/composition-graph";
+import { discoverDescriptors } from "@lorion-org/descriptor-discovery";
+import {
+  collectProviderDefaults,
+  collectProviderPreferences,
+  collectSelectedProviderPreferences,
+  resolveItemProviderSelection
+} from "@lorion-org/provider-selection";
+import {
+  applyProviderSelection,
+  assertSingleDefaultProvider,
+  descriptorSelectionPolicy,
+  providerRelationDescriptors
+} from "@lorion-org/descriptor-selection";
+
+// src/extension-descriptor.schema.json
+var extension_descriptor_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "https://lorion.dev/schemas/nuxt-extension-descriptor.schema.json",
+  $ref: "#/$defs/extension",
+  $defs: {
+    semver: {
+      type: "string",
+      pattern: "^(\\^|~)?\\d+\\.\\d+\\.\\d+$"
+    },
+    dependencyMap: {
+      type: "object",
+      additionalProperties: { $ref: "#/$defs/semver" }
+    },
+    extension: {
+      type: "object",
+      properties: {
+        id: {
+          type: "string",
+          minLength: 1
+        },
+        version: { $ref: "#/$defs/semver" },
+        providesFor: {
+          oneOf: [
+            {
+              type: "string",
+              minLength: 1
+            },
+            {
+              type: "array",
+              items: {
+                type: "string",
+                minLength: 1
+              }
+            }
+          ]
+        },
+        capabilities: {
+          type: "array",
+          items: {
+            type: "string",
+            minLength: 1
+          }
+        },
+        dependencies: { $ref: "#/$defs/dependencyMap" },
+        disabled: { type: "boolean" },
+        location: { type: "string" },
+        defaultFor: {
+          oneOf: [
+            {
+              type: "string",
+              minLength: 1
+            },
+            {
+              type: "array",
+              items: {
+                type: "string",
+                minLength: 1
+              }
+            }
+          ]
+        },
+        providerPreferences: {
+          type: "object",
+          additionalProperties: {
+            type: "string",
+            minLength: 1
+          }
+        },
+        publicRuntimeConfig: {
+          type: "object",
+          additionalProperties: true
+        },
+        runtimeConfig: {
+          type: "object",
+          properties: {
+            validation: {
+              type: "string",
+              enum: ["none", "optional", "startup", "onUse"]
+            }
+          },
+          additionalProperties: false
+        },
+        bundles: {
+          type: "array",
+          items: { $ref: "#/$defs/extension" }
+        }
+      },
+      required: ["id", "version"],
+      additionalProperties: true
+    }
+  }
+};
+
+// src/descriptor-schema.ts
+var nuxtExtensionDescriptorSchema = extension_descriptor_schema_default;
+
+// src/extensions.ts
+var defaultExtensionOptions = {
+  defaultSelection: "default",
+  publicRuntimeConfigKey: "extensionSelection",
+  descriptorPaths: ["extensions/*/extension.json"]
+};
+var defaultExtensionSelectionSeedKey = "capability";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeSelection(value) {
+  return parseDescriptorIds(value);
+}
+function resolveNuxtExtensionSelectionSeed(seedOptions) {
+  if (seedOptions === false) return [];
+  return resolveDescriptorSelectionSeed({
+    argv: seedOptions?.argv ?? process.argv,
+    env: seedOptions?.env ?? process.env,
+    key: seedOptions?.key ?? defaultExtensionSelectionSeedKey,
+    ...seedOptions?.cliKeys ? { cliKeys: seedOptions.cliKeys } : {},
+    ...seedOptions?.envKeys ? { envKeys: seedOptions.envKeys } : {}
+  });
+}
+function resolveExtensionOptions(options) {
+  return {
+    descriptorSchema: options.descriptorSchema ?? nuxtExtensionDescriptorSchema,
+    descriptorPaths: options.descriptorPaths ?? [...defaultExtensionOptions.descriptorPaths]
+  };
+}
+function resolveExtensionSelection(input = {}) {
+  const candidates = [
+    normalizeSelection(input.selected),
+    normalizeSelection(input.defaultSelection ?? defaultExtensionOptions.defaultSelection)
+  ];
+  return candidates.find((candidate) => candidate.length > 0) ?? [];
+}
+function resolveBaseExtensionSelection(input) {
+  const baseExtensions = input.options.baseExtensions;
+  return typeof baseExtensions === "function" ? normalizeSelection(baseExtensions(input)) : normalizeSelection(baseExtensions);
+}
+function optionalDir(path) {
+  return existsSync(path) ? path : void 0;
+}
+function optionalFile(path) {
+  return existsSync(path) ? path : void 0;
+}
+function findNuxtConfigFile(cwd) {
+  return ["nuxt.config.ts", "nuxt.config.mts", "nuxt.config.js", "nuxt.config.mjs"].map((fileName) => optionalFile(join(cwd, fileName))).find(Boolean);
+}
+function createExtensionEntry(input) {
+  const descriptor = {
+    ...input.descriptor,
+    location: input.descriptor.location ?? input.cwd
+  };
+  const appDir = optionalDir(join(input.cwd, "app"));
+  const modulesDir = optionalDir(join(input.cwd, "modules"));
+  const publicDir = optionalDir(join(input.cwd, "public"));
+  const serverDir = optionalDir(join(input.cwd, "server"));
+  const sharedDir = optionalDir(join(input.cwd, "shared"));
+  const configFile = findNuxtConfigFile(input.cwd);
+  const entry = {
+    cwd: input.cwd,
+    descriptor
+  };
+  if (appDir) entry.appDir = appDir;
+  if (configFile) entry.configFile = configFile;
+  if (modulesDir) entry.modulesDir = modulesDir;
+  if (publicDir) entry.publicDir = publicDir;
+  if (serverDir) entry.serverDir = serverDir;
+  if (sharedDir) entry.sharedDir = sharedDir;
+  return entry;
+}
+function canRegisterExtensionLayer(entry) {
+  return Boolean(
+    entry.appDir || entry.configFile || entry.modulesDir || entry.publicDir || entry.serverDir || entry.sharedDir
+  );
+}
+function canExtendExtensionLayer(entry) {
+  return Boolean(entry.configFile);
+}
+function discoverNuxtExtensionEntries(input) {
+  const resolvedOptions = resolveExtensionOptions(input.options);
+  return discoverDescriptors({
+    cwd: input.projectRootDir,
+    descriptorPaths: resolvedOptions.descriptorPaths,
+    nestedField: "bundles",
+    ...resolvedOptions.descriptorSchema === false ? {} : {
+      validation: {
+        schema: resolvedOptions.descriptorSchema
+      }
+    }
+  }).map(
+    (entry) => createExtensionEntry({
+      cwd: entry.cwd,
+      descriptor: entry.descriptor
+    })
+  );
+}
+function createNuxtExtensionCatalog(input) {
+  return createDescriptorCatalog({
+    descriptors: input.entries.map((entry) => entry.descriptor),
+    relationDescriptors: [...providerRelationDescriptors, ...input.relationDescriptors ?? []]
+  });
+}
+function createNuxtExtensionEntryMap(entries) {
+  return new Map(entries.map((entry) => [entry.descriptor.id, entry]));
+}
+function pickEntriesById(ids, entryById) {
+  return ids.map((id) => entryById.get(id)).filter((entry) => Boolean(entry));
+}
+function createNuxtSelectedProviderPreferences(input) {
+  return collectSelectedProviderPreferences({
+    items: input.entries,
+    getCapabilityId: (entry) => entry.descriptor.providesFor,
+    getProviderId: (entry) => entry.descriptor.id,
+    selectedProviderIds: input.selectedExtensions
+  });
+}
+function mergeRuntimeConfigSection(target = {}, source = {}) {
+  const merged = { ...target };
+  for (const [key, value] of Object.entries(source)) {
+    const current = merged[key];
+    merged[key] = isRecord(current) && isRecord(value) ? mergeRuntimeConfigSection(current, value) : value;
+  }
+  return merged;
+}
+function createExtensionSelectionRuntimeConfig(input) {
+  const runtimeConfig = input.activeExtensions.reduce(
+    (current, extension) => ({
+      ...current,
+      public: mergeRuntimeConfigSection(
+        current.public,
+        extension.descriptor.publicRuntimeConfig ?? {}
+      )
+    }),
+    { public: {} }
+  );
+  if (input.publicRuntimeConfigKey === false) return runtimeConfig;
+  return {
+    ...runtimeConfig,
+    public: {
+      ...runtimeConfig.public,
+      [defaultExtensionOptions.publicRuntimeConfigKey]: {
+        discoveredExtensionIds: input.discoveredExtensions.map((extension) => extension.descriptor.id).sort((left, right) => left.localeCompare(right)),
+        resolvedExtensionIds: input.resolvedExtensionIds,
+        selectedExtensionIds: input.selectedExtensions
+      }
+    }
+  };
+}
+function createNuxtExtensionBootstrap(input) {
+  const options = input.options ?? {};
+  const selectedExtensions = resolveExtensionSelection({
+    ...options.defaultSelection ? { defaultSelection: options.defaultSelection } : {},
+    selected: options.selected ?? resolveNuxtExtensionSelectionSeed(options.selectionSeed)
+  });
+  const createCatalog = (entries2) => createNuxtExtensionCatalog({
+    entries: entries2,
+    ...options.relationDescriptors ? { relationDescriptors: options.relationDescriptors } : {}
+  });
+  if (options.enabled === false) {
+    return {
+      activeExtensions: [],
+      baseExtensionIds: [],
+      catalog: createCatalog([]),
+      discoveredExtensions: [],
+      publicRuntimeConfig: { public: {} },
+      resolvedExtensionIds: [],
+      resolvedExtensions: [],
+      selectedExtensions
+    };
+  }
+  const entries = discoverNuxtExtensionEntries({
+    projectRootDir: input.rootDir,
+    options
+  });
+  const baseExtensionIds = resolveBaseExtensionSelection({
+    descriptors: entries.map((entry) => entry.descriptor),
+    options,
+    selectedExtensions
+  });
+  if (!entries.length) {
+    return {
+      activeExtensions: [],
+      baseExtensionIds,
+      catalog: createCatalog(entries),
+      discoveredExtensions: entries,
+      publicRuntimeConfig: { public: {} },
+      resolvedExtensionIds: [],
+      resolvedExtensions: [],
+      selectedExtensions
+    };
+  }
+  assertSingleDefaultProvider(entries.map((entry) => entry.descriptor));
+  const resolutionEntries = applyProviderSelection({
+    items: entries,
+    selected: selectedExtensions,
+    getDescriptor: (entry) => entry.descriptor,
+    withDescriptor: (entry, descriptor) => ({ ...entry, descriptor })
+  });
+  const catalog = createCatalog(resolutionEntries);
+  const selection = catalog.resolveSelection({
+    baseDescriptors: baseExtensionIds,
+    policy: descriptorSelectionPolicy(),
+    selected: selectedExtensions
+  });
+  const resolvedExtensionIds = selection.getResolved();
+  const resolvedExtensions = pickEntriesById(
+    resolvedExtensionIds,
+    createNuxtExtensionEntryMap(resolutionEntries)
+  );
+  const activeExtensions = resolvedExtensions.filter(canRegisterExtensionLayer);
+  return {
+    activeExtensions,
+    baseExtensionIds: selection.getBaseDescriptors(),
+    catalog,
+    discoveredExtensions: entries,
+    publicRuntimeConfig: createExtensionSelectionRuntimeConfig({
+      activeExtensions,
+      baseExtensionIds: selection.getBaseDescriptors(),
+      discoveredExtensions: entries,
+      publicRuntimeConfigKey: defaultExtensionOptions.publicRuntimeConfigKey,
+      resolvedExtensionIds,
+      selectedExtensions
+    }),
+    resolvedExtensionIds,
+    resolvedExtensions,
+    selectedExtensions: selection.getSelected()
+  };
+}
+function createNuxtExtensionLayerPaths(bootstrap) {
+  return bootstrap.activeExtensions.filter(canExtendExtensionLayer).map((extension) => extension.cwd);
+}
+function createNuxtProviderSelectionRuntimeConfig(extensions, options = {}) {
+  const publicRuntimeConfigKey = "providerSelection";
+  const descriptorPreferences = collectProviderPreferences({
+    items: extensions,
+    getProviderPreferences: (extension) => extension.descriptor.providerPreferences
+  });
+  const providerDefaults = collectProviderDefaults({
+    items: extensions,
+    getDefaultFor: (extension) => extension.descriptor.defaultFor,
+    getProviderId: (extension) => extension.descriptor.id
+  });
+  const configuredProviders = options.configuredProviders ?? {};
+  const selectedProviders = options.selectedProviders ?? {};
+  const fallbackProviders = {
+    ...providerDefaults,
+    ...descriptorPreferences,
+    ...options.fallbackProviders ?? {}
+  };
+  const resolution = resolveItemProviderSelection({
+    items: extensions,
+    getCapabilityId: (extension) => extension.descriptor.providesFor,
+    getProviderId: (extension) => extension.descriptor.id,
+    configuredProviders,
+    fallbackProviders,
+    selectedProviders
+  });
+  return {
+    public: {
+      [publicRuntimeConfigKey]: {
+        configuredProviders,
+        excludedProviderIds: resolution.excludedProviderIds,
+        fallbackProviders,
+        mismatches: resolution.mismatches,
+        selections: Object.fromEntries(resolution.selections)
+      }
+    }
+  };
+}
+export {
+  createNuxtExtensionBootstrap,
+  createNuxtExtensionCatalog,
+  createNuxtExtensionEntryMap,
+  createNuxtExtensionLayerPaths,
+  createNuxtProviderSelectionRuntimeConfig,
+  createNuxtSelectedProviderPreferences,
+  discoverNuxtExtensionEntries,
+  resolveExtensionSelection
+};

package/dist/index.d.ts

@@ -1,9 +1,9 @@
 import { NuxtModule } from '@nuxt/schema';
-import { N as NuxtExtensionBootstrap, a as NuxtRuntimeConfig, b as NuxtExtensionBootstrapLogEvent, L as LorionNuxtModuleOptions } from './extensions-vNob6d2x.js';
-export { c as NuxtBaseExtensionSelection, d as NuxtBaseExtensionSelectionInput, e as NuxtExtensionBootstrapReporter, f as NuxtExtensionDescriptor, g as NuxtExtensionEntry, h as NuxtExtensionModuleOptions, i as NuxtProviderSelectionModuleOptions, j as NuxtProviderSelectionRuntimeConfig, R as RuntimeConfigNuxtModuleOptions, k as createNuxtExtensionBootstrap, l as createNuxtExtensionLayerPaths, m as createNuxtProviderSelectionRuntimeConfig, r as resolveExtensionSelection } from './extensions-vNob6d2x.js';
+import { N as NuxtExtensionBootstrap, a as NuxtRuntimeConfig, b as NuxtExtensionBootstrapLogEvent, L as LorionNuxtModuleOptions } from './extensions-DlFRz22Q.js';
+export { c as NuxtBaseExtensionSelection, d as NuxtBaseExtensionSelectionInput, e as NuxtExtensionBootstrapReporter, f as NuxtExtensionDescriptor, g as NuxtExtensionEntry, h as NuxtExtensionModuleOptions, i as NuxtExtensionSelectionSeedOptions, j as NuxtProviderSelectionModuleOptions, k as NuxtProviderSelectionRuntimeConfig, R as RuntimeConfigNuxtModuleOptions, l as createNuxtExtensionBootstrap, m as createNuxtExtensionCatalog, n as createNuxtExtensionEntryMap, o as createNuxtExtensionLayerPaths, p as createNuxtProviderSelectionRuntimeConfig, q as discoverNuxtExtensionEntries, r as resolveExtensionSelection } from './extensions-DlFRz22Q.js';
+export { JsonSchemaObject, nuxtExtensionDescriptorSchema } from './descriptor-schema.js';
 import '@lorion-org/composition-graph';
 import '@lorion-org/provider-selection';
-import '@lorion-org/descriptor-discovery';
 import '@lorion-org/runtime-config';
 import '@lorion-org/runtime-config-node';