@kitsy/cnos-webpack 1.5.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 kitsy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,5 @@
+# @kitsy/cnos-webpack
+
+Webpack integration for CNOS.
+
+It resolves CNOS public config during webpack startup, injects `process.env.*` define replacements for promoted public values, and embeds `globalThis.__CNOS_BROWSER_DATA__` for `@kitsy/cnos/browser`.

package/dist/index.cjs

@@ -0,0 +1,147 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CnosWebpackPlugin: () => CnosWebpackPlugin,
+  loadCnosWebpackEnv: () => loadCnosWebpackEnv,
+  loadCnosWebpackRuntime: () => loadCnosWebpackRuntime,
+  resolveCnosWebpackBindings: () => resolveCnosWebpackBindings,
+  resolveCnosWebpackBuildConfig: () => resolveCnosWebpackBuildConfig
+});
+module.exports = __toCommonJS(index_exports);
+var import_build = require("@kitsy/cnos/build");
+var import_configure = require("@kitsy/cnos/configure");
+var PLUGIN_NAME = "CnosWebpackPlugin";
+async function loadCnosWebpackEnv(options = {}) {
+  return (0, import_build.resolveFrameworkEnv)(options, "webpack", {
+    ...options.prefix ? { prefix: options.prefix } : {}
+  });
+}
+async function resolveCnosWebpackBindings(options = {}) {
+  const [browserData, publicEnv] = await Promise.all([
+    (0, import_build.resolveBrowserData)(options),
+    loadCnosWebpackEnv(options)
+  ]);
+  const definitions = {
+    "globalThis.__CNOS_BROWSER_DATA__": JSON.stringify(JSON.stringify(browserData))
+  };
+  if (options.includeProcessEnvShim ?? true) {
+    definitions["process.env.__CNOS_BROWSER_DATA__"] = JSON.stringify(JSON.stringify(browserData));
+  }
+  for (const [key, value] of Object.entries(publicEnv)) {
+    definitions[`process.env.${key}`] = JSON.stringify(value);
+  }
+  return {
+    browserData,
+    publicEnv,
+    definitions
+  };
+}
+function createDynamicDefinitions(DefinePlugin, state, keys, options) {
+  const definitions = {
+    "globalThis.__CNOS_BROWSER_DATA__": DefinePlugin.runtimeValue(
+      () => JSON.stringify(JSON.stringify(state.browserData)),
+      true
+    )
+  };
+  if (options.includeProcessEnvShim ?? true) {
+    definitions["process.env.__CNOS_BROWSER_DATA__"] = DefinePlugin.runtimeValue(
+      () => JSON.stringify(JSON.stringify(state.browserData)),
+      true
+    );
+  }
+  for (const key of keys) {
+    definitions[`process.env.${key}`] = DefinePlugin.runtimeValue(
+      () => JSON.stringify(state.publicEnv[key] ?? ""),
+      true
+    );
+  }
+  return definitions;
+}
+var CnosWebpackPlugin = class {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  apply(compiler) {
+    const state = {
+      browserData: {},
+      publicEnv: {}
+    };
+    let initialized = false;
+    let knownKeys = /* @__PURE__ */ new Set();
+    const updateState = async () => {
+      const bindings = await resolveCnosWebpackBindings(this.options);
+      state.browserData = bindings.browserData;
+      state.publicEnv = bindings.publicEnv;
+      if (initialized) {
+        return;
+      }
+      knownKeys = new Set(Object.keys(bindings.publicEnv));
+      const definitions = createDynamicDefinitions(
+        compiler.webpack.DefinePlugin,
+        state,
+        [...knownKeys],
+        this.options
+      );
+      new compiler.webpack.DefinePlugin(definitions).apply(compiler);
+      initialized = true;
+    };
+    compiler.hooks.beforeRun.tapPromise(PLUGIN_NAME, async () => {
+      await updateState();
+    });
+    compiler.hooks.watchRun.tapPromise(PLUGIN_NAME, async () => {
+      const wasInitialized = initialized;
+      const previousKeys = new Set(knownKeys);
+      await updateState();
+      if (wasInitialized && Object.keys(state.publicEnv).some((key) => !previousKeys.has(key))) {
+        process.stderr.write(
+          "[cnos-webpack] New public env keys were detected during watch mode. Restart webpack to apply new define entries.\n"
+        );
+      }
+    });
+  }
+};
+async function loadCnosWebpackRuntime(options = {}) {
+  return (0, import_configure.createCnos)(options);
+}
+async function resolveCnosWebpackBuildConfig(options = {}) {
+  const [runtime, browserData, publicEnv] = await Promise.all([
+    (0, import_configure.createCnos)(options),
+    (0, import_build.resolveBrowserData)(options),
+    (0, import_build.resolveFrameworkEnv)(options, "webpack", {
+      ...options.prefix ? { prefix: options.prefix } : {}
+    })
+  ]);
+  return {
+    runtime,
+    browserData,
+    publicEnv
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CnosWebpackPlugin,
+  loadCnosWebpackEnv,
+  loadCnosWebpackRuntime,
+  resolveCnosWebpackBindings,
+  resolveCnosWebpackBuildConfig
+});

package/dist/index.d.cts

@@ -0,0 +1,242 @@
+export { FrameworkEnvTarget } from '@kitsy/cnos/build';
+import { CnosCreateOptions, createCnos } from '@kitsy/cnos/configure';
+
+type ProfileResolveFrom = 'cli.profile' | 'env.CNOS_PROFILE' | 'default';
+type ProfileSource = 'cli' | 'workspace-file' | 'env' | 'manifest-default';
+
+interface SchemaRule {
+    type?: 'string' | 'number' | 'boolean' | 'object' | 'array';
+    required?: boolean;
+    enum?: unknown[];
+    pattern?: string;
+    default?: unknown;
+}
+
+type WorkspaceSource = 'cli' | 'workspace-file' | 'manifest-default' | 'implicit';
+type GlobalRootSource = 'cli' | 'workspace-file' | 'manifest' | 'CNOS_HOME';
+interface NormalizedWorkspaceItem {
+    extends: string[];
+    globalId?: string;
+}
+interface WorkspaceRoot {
+    scope: 'global' | 'local';
+    workspaceId: string;
+    path: string;
+}
+interface WorkspaceContext {
+    workspaceId: string;
+    workspaceSource: WorkspaceSource;
+    globalRoot?: string;
+    globalRootSource?: GlobalRootSource;
+    workspaceChain: string[];
+    workspaceRoots: WorkspaceRoot[];
+}
+
+type ResolutionArrayPolicy = 'replace' | 'append' | 'unique-append';
+type NamespaceKind = 'data' | 'projection' | 'system';
+type NamespaceProjectionSource = 'promote' | 'envMapping';
+type VaultProviderName = 'local' | 'github-secrets' | (string & {});
+type VaultAuthMethod = 'passphrase' | 'environment' | 'token' | 'iam' | 'keychain';
+interface VaultAuthSourceConfig {
+    from?: string[];
+}
+interface VaultAuthDefinition {
+    method?: VaultAuthMethod;
+    passphrase?: VaultAuthSourceConfig;
+    token?: VaultAuthSourceConfig;
+    config?: Record<string, unknown>;
+}
+interface NamespaceDefinition {
+    kind: NamespaceKind;
+    shareable: boolean;
+    sensitive?: boolean;
+    readonly?: boolean;
+    source?: NamespaceProjectionSource;
+}
+interface VaultDefinition {
+    provider: VaultProviderName;
+    auth?: VaultAuthDefinition;
+    mapping?: Record<string, string>;
+}
+interface NormalizedManifest {
+    version: 1;
+    project: {
+        name: string;
+    };
+    workspaces: {
+        default?: string;
+        global: {
+            enabled: boolean;
+            root?: string;
+            allowWrite: boolean;
+        };
+        items: Record<string, NormalizedWorkspaceItem>;
+    };
+    profiles: {
+        default: string;
+        resolveFrom: ProfileResolveFrom[];
+    };
+    plugins: {
+        loaders: string[];
+        resolver: string;
+        validators: string[];
+        exporters: string[];
+        inspectors: string[];
+    };
+    sources: Record<string, Record<string, unknown>>;
+    resolution: {
+        precedence: string[];
+        arrayPolicy: ResolutionArrayPolicy;
+    };
+    envMapping: {
+        convention?: 'SCREAMING_SNAKE';
+        explicit: Record<string, LogicalKey>;
+    };
+    public: {
+        promote: LogicalKey[];
+        frameworks: Record<string, string>;
+    };
+    namespaces: Record<string, NamespaceDefinition>;
+    vaults: Record<string, VaultDefinition>;
+    writePolicy: {
+        define: {
+            defaultProfile: string;
+            targets: Record<'value' | 'secret', string>;
+        };
+    };
+    schema: Record<LogicalKey, SchemaRule>;
+}
+
+type LogicalKey = string;
+type NamespaceName = string;
+interface ConfigOrigin {
+    file?: string;
+    line?: number;
+    envVar?: string;
+    cliArg?: string;
+}
+interface ConfigEntry {
+    key: LogicalKey;
+    value: unknown;
+    namespace: NamespaceName;
+    sourceId: string;
+    pluginId: string;
+    workspaceId: string;
+    profile?: string;
+    origin?: ConfigOrigin;
+    metadata?: Record<string, unknown>;
+}
+interface ResolvedEntry {
+    key: LogicalKey;
+    value: unknown;
+    namespace: NamespaceName;
+    winner: ConfigEntry;
+    overridden: ConfigEntry[];
+}
+interface ResolvedGraph {
+    entries: Map<LogicalKey, ResolvedEntry>;
+    profile: string;
+    resolvedAt: string;
+    profileSource: ProfileSource;
+    workspace: WorkspaceContext;
+}
+interface InspectResult {
+    key: LogicalKey;
+    value: unknown;
+    namespace: NamespaceName;
+    profile: string;
+    profileSource: ProfileSource;
+    workspace: {
+        id: string;
+        source: WorkspaceContext['workspaceSource'];
+        chain: string[];
+    };
+    winner: {
+        sourceId: string;
+        pluginId: string;
+        workspaceId: string;
+        origin?: ConfigOrigin;
+    };
+    overridden: Array<{
+        sourceId: string;
+        pluginId: string;
+        workspaceId: string;
+        value: unknown;
+        origin?: ConfigOrigin;
+    }>;
+}
+interface ToEnvOptions {
+    includeSecrets?: boolean;
+}
+interface ToPublicEnvOptions {
+    framework?: string;
+    prefix?: string;
+}
+interface CnosRuntime {
+    manifest: NormalizedManifest;
+    plugins: CnosPlugin[];
+    readonly graph: ResolvedGraph;
+    read<T = unknown>(key: LogicalKey): T | undefined;
+    require<T = unknown>(key: LogicalKey): T;
+    readOr<T>(key: LogicalKey, fallback: T): T;
+    value<T = unknown>(path: string): T | undefined;
+    secret<T = unknown>(path: string): T | undefined;
+    meta<T = unknown>(path: string): T | undefined;
+    inspect(key: LogicalKey): InspectResult;
+    toObject(): Record<string, unknown>;
+    toNamespace(namespace: NamespaceName): Record<string, unknown>;
+    toEnv(options?: ToEnvOptions): Record<string, string>;
+    toPublicEnv(options?: ToPublicEnvOptions): Record<string, string>;
+}
+
+type CnosPluginKind = 'loader' | 'resolver' | 'validator' | 'exporter' | 'inspector';
+interface CnosPlugin {
+    id: string;
+    kind: CnosPluginKind;
+}
+
+interface CnosWebpackPluginOptions extends CnosCreateOptions {
+    prefix?: string;
+    includeProcessEnvShim?: boolean;
+}
+interface CnosWebpackBindings {
+    browserData: Record<string, unknown>;
+    publicEnv: Record<string, string>;
+    definitions: Record<string, unknown>;
+}
+interface WebpackLikeDefinePluginInstance {
+    apply(compiler: WebpackCompilerLike): void;
+}
+interface WebpackLikeDefinePluginConstructor {
+    new (definitions: Record<string, unknown>): WebpackLikeDefinePluginInstance;
+    runtimeValue(getter: () => string, watched: true | string[] | {
+        fileDependencies?: string[];
+    }): unknown;
+}
+interface TapPromiseHookLike<TArgs extends unknown[] = []> {
+    tapPromise(name: string, handler: (...args: TArgs) => Promise<void>): void;
+}
+interface WebpackCompilerLike {
+    webpack: {
+        DefinePlugin: WebpackLikeDefinePluginConstructor;
+    };
+    hooks: {
+        beforeRun: TapPromiseHookLike<[WebpackCompilerLike]>;
+        watchRun: TapPromiseHookLike<[WebpackCompilerLike]>;
+    };
+}
+declare function loadCnosWebpackEnv(options?: CnosWebpackPluginOptions): Promise<Record<string, string>>;
+declare function resolveCnosWebpackBindings(options?: CnosWebpackPluginOptions): Promise<CnosWebpackBindings>;
+declare class CnosWebpackPlugin {
+    readonly options: CnosWebpackPluginOptions;
+    constructor(options?: CnosWebpackPluginOptions);
+    apply(compiler: WebpackCompilerLike): void;
+}
+declare function loadCnosWebpackRuntime(options?: CnosCreateOptions): Promise<CnosRuntime>;
+declare function resolveCnosWebpackBuildConfig(options?: CnosWebpackPluginOptions): Promise<{
+    runtime: Awaited<ReturnType<typeof createCnos>>;
+    browserData: Record<string, unknown>;
+    publicEnv: Record<string, string>;
+}>;
+
+export { type CnosWebpackBindings, CnosWebpackPlugin, type CnosWebpackPluginOptions, type TapPromiseHookLike, type WebpackCompilerLike, type WebpackLikeDefinePluginConstructor, type WebpackLikeDefinePluginInstance, loadCnosWebpackEnv, loadCnosWebpackRuntime, resolveCnosWebpackBindings, resolveCnosWebpackBuildConfig };

package/dist/index.d.ts

@@ -0,0 +1,242 @@
+export { FrameworkEnvTarget } from '@kitsy/cnos/build';
+import { CnosCreateOptions, createCnos } from '@kitsy/cnos/configure';
+
+type ProfileResolveFrom = 'cli.profile' | 'env.CNOS_PROFILE' | 'default';
+type ProfileSource = 'cli' | 'workspace-file' | 'env' | 'manifest-default';
+
+interface SchemaRule {
+    type?: 'string' | 'number' | 'boolean' | 'object' | 'array';
+    required?: boolean;
+    enum?: unknown[];
+    pattern?: string;
+    default?: unknown;
+}
+
+type WorkspaceSource = 'cli' | 'workspace-file' | 'manifest-default' | 'implicit';
+type GlobalRootSource = 'cli' | 'workspace-file' | 'manifest' | 'CNOS_HOME';
+interface NormalizedWorkspaceItem {
+    extends: string[];
+    globalId?: string;
+}
+interface WorkspaceRoot {
+    scope: 'global' | 'local';
+    workspaceId: string;
+    path: string;
+}
+interface WorkspaceContext {
+    workspaceId: string;
+    workspaceSource: WorkspaceSource;
+    globalRoot?: string;
+    globalRootSource?: GlobalRootSource;
+    workspaceChain: string[];
+    workspaceRoots: WorkspaceRoot[];
+}
+
+type ResolutionArrayPolicy = 'replace' | 'append' | 'unique-append';
+type NamespaceKind = 'data' | 'projection' | 'system';
+type NamespaceProjectionSource = 'promote' | 'envMapping';
+type VaultProviderName = 'local' | 'github-secrets' | (string & {});
+type VaultAuthMethod = 'passphrase' | 'environment' | 'token' | 'iam' | 'keychain';
+interface VaultAuthSourceConfig {
+    from?: string[];
+}
+interface VaultAuthDefinition {
+    method?: VaultAuthMethod;
+    passphrase?: VaultAuthSourceConfig;
+    token?: VaultAuthSourceConfig;
+    config?: Record<string, unknown>;
+}
+interface NamespaceDefinition {
+    kind: NamespaceKind;
+    shareable: boolean;
+    sensitive?: boolean;
+    readonly?: boolean;
+    source?: NamespaceProjectionSource;
+}
+interface VaultDefinition {
+    provider: VaultProviderName;
+    auth?: VaultAuthDefinition;
+    mapping?: Record<string, string>;
+}
+interface NormalizedManifest {
+    version: 1;
+    project: {
+        name: string;
+    };
+    workspaces: {
+        default?: string;
+        global: {
+            enabled: boolean;
+            root?: string;
+            allowWrite: boolean;
+        };
+        items: Record<string, NormalizedWorkspaceItem>;
+    };
+    profiles: {
+        default: string;
+        resolveFrom: ProfileResolveFrom[];
+    };
+    plugins: {
+        loaders: string[];
+        resolver: string;
+        validators: string[];
+        exporters: string[];
+        inspectors: string[];
+    };
+    sources: Record<string, Record<string, unknown>>;
+    resolution: {
+        precedence: string[];
+        arrayPolicy: ResolutionArrayPolicy;
+    };
+    envMapping: {
+        convention?: 'SCREAMING_SNAKE';
+        explicit: Record<string, LogicalKey>;
+    };
+    public: {
+        promote: LogicalKey[];
+        frameworks: Record<string, string>;
+    };
+    namespaces: Record<string, NamespaceDefinition>;
+    vaults: Record<string, VaultDefinition>;
+    writePolicy: {
+        define: {
+            defaultProfile: string;
+            targets: Record<'value' | 'secret', string>;
+        };
+    };
+    schema: Record<LogicalKey, SchemaRule>;
+}
+
+type LogicalKey = string;
+type NamespaceName = string;
+interface ConfigOrigin {
+    file?: string;
+    line?: number;
+    envVar?: string;
+    cliArg?: string;
+}
+interface ConfigEntry {
+    key: LogicalKey;
+    value: unknown;
+    namespace: NamespaceName;
+    sourceId: string;
+    pluginId: string;
+    workspaceId: string;
+    profile?: string;
+    origin?: ConfigOrigin;
+    metadata?: Record<string, unknown>;
+}
+interface ResolvedEntry {
+    key: LogicalKey;
+    value: unknown;
+    namespace: NamespaceName;
+    winner: ConfigEntry;
+    overridden: ConfigEntry[];
+}
+interface ResolvedGraph {
+    entries: Map<LogicalKey, ResolvedEntry>;
+    profile: string;
+    resolvedAt: string;
+    profileSource: ProfileSource;
+    workspace: WorkspaceContext;
+}
+interface InspectResult {
+    key: LogicalKey;
+    value: unknown;
+    namespace: NamespaceName;
+    profile: string;
+    profileSource: ProfileSource;
+    workspace: {
+        id: string;
+        source: WorkspaceContext['workspaceSource'];
+        chain: string[];
+    };
+    winner: {
+        sourceId: string;
+        pluginId: string;
+        workspaceId: string;
+        origin?: ConfigOrigin;
+    };
+    overridden: Array<{
+        sourceId: string;
+        pluginId: string;
+        workspaceId: string;
+        value: unknown;
+        origin?: ConfigOrigin;
+    }>;
+}
+interface ToEnvOptions {
+    includeSecrets?: boolean;
+}
+interface ToPublicEnvOptions {
+    framework?: string;
+    prefix?: string;
+}
+interface CnosRuntime {
+    manifest: NormalizedManifest;
+    plugins: CnosPlugin[];
+    readonly graph: ResolvedGraph;
+    read<T = unknown>(key: LogicalKey): T | undefined;
+    require<T = unknown>(key: LogicalKey): T;
+    readOr<T>(key: LogicalKey, fallback: T): T;
+    value<T = unknown>(path: string): T | undefined;
+    secret<T = unknown>(path: string): T | undefined;
+    meta<T = unknown>(path: string): T | undefined;
+    inspect(key: LogicalKey): InspectResult;
+    toObject(): Record<string, unknown>;
+    toNamespace(namespace: NamespaceName): Record<string, unknown>;
+    toEnv(options?: ToEnvOptions): Record<string, string>;
+    toPublicEnv(options?: ToPublicEnvOptions): Record<string, string>;
+}
+
+type CnosPluginKind = 'loader' | 'resolver' | 'validator' | 'exporter' | 'inspector';
+interface CnosPlugin {
+    id: string;
+    kind: CnosPluginKind;
+}
+
+interface CnosWebpackPluginOptions extends CnosCreateOptions {
+    prefix?: string;
+    includeProcessEnvShim?: boolean;
+}
+interface CnosWebpackBindings {
+    browserData: Record<string, unknown>;
+    publicEnv: Record<string, string>;
+    definitions: Record<string, unknown>;
+}
+interface WebpackLikeDefinePluginInstance {
+    apply(compiler: WebpackCompilerLike): void;
+}
+interface WebpackLikeDefinePluginConstructor {
+    new (definitions: Record<string, unknown>): WebpackLikeDefinePluginInstance;
+    runtimeValue(getter: () => string, watched: true | string[] | {
+        fileDependencies?: string[];
+    }): unknown;
+}
+interface TapPromiseHookLike<TArgs extends unknown[] = []> {
+    tapPromise(name: string, handler: (...args: TArgs) => Promise<void>): void;
+}
+interface WebpackCompilerLike {
+    webpack: {
+        DefinePlugin: WebpackLikeDefinePluginConstructor;
+    };
+    hooks: {
+        beforeRun: TapPromiseHookLike<[WebpackCompilerLike]>;
+        watchRun: TapPromiseHookLike<[WebpackCompilerLike]>;
+    };
+}
+declare function loadCnosWebpackEnv(options?: CnosWebpackPluginOptions): Promise<Record<string, string>>;
+declare function resolveCnosWebpackBindings(options?: CnosWebpackPluginOptions): Promise<CnosWebpackBindings>;
+declare class CnosWebpackPlugin {
+    readonly options: CnosWebpackPluginOptions;
+    constructor(options?: CnosWebpackPluginOptions);
+    apply(compiler: WebpackCompilerLike): void;
+}
+declare function loadCnosWebpackRuntime(options?: CnosCreateOptions): Promise<CnosRuntime>;
+declare function resolveCnosWebpackBuildConfig(options?: CnosWebpackPluginOptions): Promise<{
+    runtime: Awaited<ReturnType<typeof createCnos>>;
+    browserData: Record<string, unknown>;
+    publicEnv: Record<string, string>;
+}>;
+
+export { type CnosWebpackBindings, CnosWebpackPlugin, type CnosWebpackPluginOptions, type TapPromiseHookLike, type WebpackCompilerLike, type WebpackLikeDefinePluginConstructor, type WebpackLikeDefinePluginInstance, loadCnosWebpackEnv, loadCnosWebpackRuntime, resolveCnosWebpackBindings, resolveCnosWebpackBuildConfig };

package/dist/index.js

@@ -0,0 +1,118 @@
+// src/index.ts
+import { resolveBrowserData, resolveFrameworkEnv } from "@kitsy/cnos/build";
+import { createCnos } from "@kitsy/cnos/configure";
+var PLUGIN_NAME = "CnosWebpackPlugin";
+async function loadCnosWebpackEnv(options = {}) {
+  return resolveFrameworkEnv(options, "webpack", {
+    ...options.prefix ? { prefix: options.prefix } : {}
+  });
+}
+async function resolveCnosWebpackBindings(options = {}) {
+  const [browserData, publicEnv] = await Promise.all([
+    resolveBrowserData(options),
+    loadCnosWebpackEnv(options)
+  ]);
+  const definitions = {
+    "globalThis.__CNOS_BROWSER_DATA__": JSON.stringify(JSON.stringify(browserData))
+  };
+  if (options.includeProcessEnvShim ?? true) {
+    definitions["process.env.__CNOS_BROWSER_DATA__"] = JSON.stringify(JSON.stringify(browserData));
+  }
+  for (const [key, value] of Object.entries(publicEnv)) {
+    definitions[`process.env.${key}`] = JSON.stringify(value);
+  }
+  return {
+    browserData,
+    publicEnv,
+    definitions
+  };
+}
+function createDynamicDefinitions(DefinePlugin, state, keys, options) {
+  const definitions = {
+    "globalThis.__CNOS_BROWSER_DATA__": DefinePlugin.runtimeValue(
+      () => JSON.stringify(JSON.stringify(state.browserData)),
+      true
+    )
+  };
+  if (options.includeProcessEnvShim ?? true) {
+    definitions["process.env.__CNOS_BROWSER_DATA__"] = DefinePlugin.runtimeValue(
+      () => JSON.stringify(JSON.stringify(state.browserData)),
+      true
+    );
+  }
+  for (const key of keys) {
+    definitions[`process.env.${key}`] = DefinePlugin.runtimeValue(
+      () => JSON.stringify(state.publicEnv[key] ?? ""),
+      true
+    );
+  }
+  return definitions;
+}
+var CnosWebpackPlugin = class {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  apply(compiler) {
+    const state = {
+      browserData: {},
+      publicEnv: {}
+    };
+    let initialized = false;
+    let knownKeys = /* @__PURE__ */ new Set();
+    const updateState = async () => {
+      const bindings = await resolveCnosWebpackBindings(this.options);
+      state.browserData = bindings.browserData;
+      state.publicEnv = bindings.publicEnv;
+      if (initialized) {
+        return;
+      }
+      knownKeys = new Set(Object.keys(bindings.publicEnv));
+      const definitions = createDynamicDefinitions(
+        compiler.webpack.DefinePlugin,
+        state,
+        [...knownKeys],
+        this.options
+      );
+      new compiler.webpack.DefinePlugin(definitions).apply(compiler);
+      initialized = true;
+    };
+    compiler.hooks.beforeRun.tapPromise(PLUGIN_NAME, async () => {
+      await updateState();
+    });
+    compiler.hooks.watchRun.tapPromise(PLUGIN_NAME, async () => {
+      const wasInitialized = initialized;
+      const previousKeys = new Set(knownKeys);
+      await updateState();
+      if (wasInitialized && Object.keys(state.publicEnv).some((key) => !previousKeys.has(key))) {
+        process.stderr.write(
+          "[cnos-webpack] New public env keys were detected during watch mode. Restart webpack to apply new define entries.\n"
+        );
+      }
+    });
+  }
+};
+async function loadCnosWebpackRuntime(options = {}) {
+  return createCnos(options);
+}
+async function resolveCnosWebpackBuildConfig(options = {}) {
+  const [runtime, browserData, publicEnv] = await Promise.all([
+    createCnos(options),
+    resolveBrowserData(options),
+    resolveFrameworkEnv(options, "webpack", {
+      ...options.prefix ? { prefix: options.prefix } : {}
+    })
+  ]);
+  return {
+    runtime,
+    browserData,
+    publicEnv
+  };
+}
+export {
+  CnosWebpackPlugin,
+  loadCnosWebpackEnv,
+  loadCnosWebpackRuntime,
+  resolveCnosWebpackBindings,
+  resolveCnosWebpackBuildConfig
+};

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@kitsy/cnos-webpack",
+  "version": "1.5.0",
+  "description": "Webpack integration for CNOS public config injection.",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kitsyai/cnos.git",
+    "directory": "packages/webpack"
+  },
+  "homepage": "https://github.com/kitsyai/cnos/tree/main/packages/webpack",
+  "bugs": {
+    "url": "https://github.com/kitsyai/cnos/issues"
+  },
+  "keywords": [
+    "cnos",
+    "webpack",
+    "config"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@kitsy/cnos": "1.5.0"
+  },
+  "peerDependencies": {
+    "webpack": ">=5"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts",
+    "clean": "rimraf dist",
+    "dev": "tsup src/index.ts --watch --format esm,cjs --dts",
+    "lint": "eslint src test",
+    "test": "vitest run",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  }
+}