@appshell/webpack-plugin 1.0.0-alpha.24 → 1.0.0-alpha.25

package/dist/types/config/src/index.d.ts

@@ -11,6 +11,6 @@ export { default as outdated } from './outdated';
 export { activate, publish } from './publish';
 export type { PublishOptions, PublishResult } from './publish';
 export { default as sync } from './sync';
-export type { AppshellComposition, AppshellConfig, AppshellConfigRemote, AppshellIndex, AppshellManifest, AppshellRemote, AppshellTemplate, AppshellTokenUsage, ComparisonResult, ComparisonResults, ComparisonTarget, Metadata, ModuleFederationPluginOptions, PackageSpec, ResolvedRemote, Schema, SharedConfig, SharedModuleSpec, } from './types';
+export type { AppshellComposition, AppshellConfig, AppshellConfigRemote, AppshellIndex, AppshellManifest, AppshellRemote, AppshellTemplate, AppshellTokenUsage, ComparisonResult, ComparisonResults, ComparisonTarget, Metadata, ModuleFederationPluginOptions, PackageSpec, ResolvedRemote, Schema, SharedConfig, SharedObject, SharedModuleSpec, } from './types';
 export * as utils from './utils';
 export * as validators from './validators';

package/dist/types/config/src/types.d.ts

@@ -1,4 +1,6 @@
+import type { AppshellIndex, AppshellRemote, Metadata } from '@appshell/runtime';
 import { JSONSchema4, JSONSchema6, JSONSchema7 } from 'json-schema';
+export type { AppshellIndex, AppshellRemote, Metadata } from '@appshell/runtime';
 export type Schema = JSONSchema4 | JSONSchema6 | JSONSchema7;
 export type ConfigValidator = {
     validate: <T>(...config: T[]) => void;
@@ -72,15 +74,6 @@ export type AppshellTemplate<TMetadata = Metadata> = {
     overrides?: AppshellOverrides;
 };
 /** Appshell manifest types */
-export type AppshellRemote<TMetadata = Metadata> = {
-    id: string;
-    manifestUrl: string;
-    remoteEntryUrl: string;
-    scope: string;
-    module: string;
-    shareScope?: string;
-    metadata: TMetadata;
-};
 export type AppshellOverrides = {
     vars: Record<string, Record<string, string | number | undefined>>;
 };
@@ -105,8 +98,6 @@ export type AppshellManifest<TMetadata = Metadata> = {
     tokens?: Record<string, AppshellTokenUsage>;
     overrides?: AppshellOverrides;
 };
-export type AppshellIndex = Record<string, string>;
-export type Metadata = Record<string, unknown>;
 /** An `AppshellRemote` the registry already resolved, so the browser needs no manifest fetch. */
 export type ResolvedRemote<TMetadata = Metadata> = AppshellRemote<TMetadata>;
 /**

package/dist/types/runtime/src/errors.d.ts

@@ -0,0 +1,32 @@
+/**
+ * A package asked for vars that were never delivered.
+ *
+ * Almost always one of three things: the package was loaded outside `remoteLoader`
+ * (a test, a storybook, a direct import), the host and the package resolved separate
+ * copies of `@appshell/runtime` because one of them failed to declare it as a
+ * singleton, or the scope compiled into the package is not the scope the registry
+ * knows it by.
+ */
+export declare class MissingVarsError extends Error {
+    readonly scope: string;
+    constructor(scope: string, known: string[]);
+}
+/**
+ * Something tried to replace vars that were already delivered for a scope.
+ *
+ * The first write wins and is final. Within one page load a scope has exactly one
+ * vars object — both resolvers read it from the same `composition.vars[scope]` — so a
+ * differing second write is a bug or a package reaching for a scope that is not its own,
+ * and neither should be applied quietly.
+ */
+export declare class VarsConflictError extends Error {
+    readonly scope: string;
+    constructor(scope: string);
+}
+/**
+ * The package was built without `AppshellPlugin`, so nothing substituted the scope the
+ * `@appshell/runtime/vars` accessor needs to know which vars are its own.
+ */
+export declare class MissingScopeError extends Error {
+    constructor();
+}

package/dist/types/runtime/src/index.d.ts

@@ -0,0 +1,4 @@
+export { MissingScopeError, MissingVarsError, VarsConflictError } from './errors';
+export { hasVars, readVars, resetVars, setVars } from './store';
+export type { Vars } from './types';
+export type { AppshellIndex, AppshellRemote, Metadata } from './wire';

package/dist/types/runtime/src/store.d.ts

@@ -0,0 +1,25 @@
+import type { Vars } from './types';
+/**
+ * Delivers a scope's vars. Called by `@appshell/loader` immediately before the remote
+ * is loaded, so they are in place before the package's modules evaluate.
+ *
+ * The first write for a scope wins and is frozen. Re-delivering the identical vars is a
+ * no-op — the same remote can be mounted more than once — but replacing them throws.
+ * That is what keeps one package from overwriting another's: by the time any package
+ * evaluates, the host has already written for it.
+ *
+ * It does not make a scope's vars *private*. Any code on the page can still read another
+ * scope by name, and nothing short of a separate realm would change that.
+ */
+export declare const setVars: (scope: string, vars: Vars) => void;
+/**
+ * Reads a scope's vars, throwing rather than handing back an empty object — a package
+ * that silently renders with no configuration is the failure this replaced.
+ *
+ * Prefer `getVars()` from `@appshell/runtime/vars`, which supplies the scope for you.
+ */
+export declare const readVars: <TVars extends Vars = Vars>(scope: string) => TVars;
+/** Whether a scope has been delivered, for callers that want to branch instead of catch. */
+export declare const hasVars: (scope: string) => boolean;
+/** Test seam. Not part of the contract a package should build on. */
+export declare const resetVars: () => void;

package/dist/types/runtime/src/types.d.ts

@@ -0,0 +1,9 @@
+/**
+ * A package's runtime configuration, already merged by the registry — a package's
+ * declared vars, then the application's `overrides.vars`.
+ *
+ * Structurally identical to `AppshellComposition['vars'][scope]` in `@appshell/config`,
+ * but declared here rather than imported. This package is a shared singleton loaded
+ * into every micro-frontend on the page, so it carries no dependencies at all.
+ */
+export type Vars = Record<string, string | number | undefined>;

package/dist/types/runtime/src/wire.d.ts

@@ -0,0 +1,26 @@
+/**
+ * What the browser is told about a remote.
+ *
+ * These live here rather than in `@appshell/config` because config is build tooling — it
+ * carries yaml, lodash and axios — and a package that only wants to type a remote should
+ * not install a compiler to get it. This package is already the one every micro-frontend
+ * on the page shares, and it has no dependencies of its own to pass on.
+ *
+ * `AppshellManifest` deliberately stays in `@appshell/config`. It is a build artifact, and
+ * its `modules` field is Module Federation plugin options — build-time webpack
+ * configuration the browser never sees and this package should never drag in.
+ */
+/** Arbitrary, application-defined description of a remote. Appshell never reads it. */
+export type Metadata = Record<string, unknown>;
+/** A remote the registry has already resolved, so the browser needs no manifest fetch. */
+export type AppshellRemote<TMetadata = Metadata> = {
+    id: string;
+    manifestUrl: string;
+    remoteEntryUrl: string;
+    scope: string;
+    module: string;
+    shareScope?: string;
+    metadata: TMetadata;
+};
+/** Remote key to manifest url. */
+export type AppshellIndex = Record<string, string>;

package/dist/types/webpack-plugin/src/index.d.ts

@@ -5,3 +5,4 @@ export type { AppshellManifest } from '@appshell/config';
 export { default as AppshellPlugin } from './AppshellPlugin';
 export { DEV_HINT_FILE, DEV_HINT_VERSION, devServerOrigin, writeDevHint } from './devHint';
 export type { DevHint } from './devHint';
+export { appshellShared, type AppshellSharedOptions } from './shared';

package/dist/types/webpack-plugin/src/shared.d.ts

@@ -0,0 +1,36 @@
+import type { SharedObject } from '@appshell/config';
+export type AppshellSharedOptions = {
+    /** Include the React bindings and React itself. */
+    react?: boolean;
+    /**
+     * Usually your package.json `dependencies`. Anything named here is pinned to the range
+     * you depend on; anything absent is left for module federation to infer, which it does
+     * from the installed package.
+     */
+    dependencies?: Record<string, string>;
+    /** Merged last, so a package can still say something the preset does not. */
+    extra?: SharedObject;
+};
+/**
+ * The `shared` block an Appshell package needs, so it is not written out by hand in every
+ * webpack config and wrong in one of them.
+ *
+ * It exists because the alternative failed in practice: the examples in this repo declared
+ * `@appshell/react` as a singleton in three configs and omitted it in a fourth, which is
+ * silent until a root package calls `useRemote()` and gets `undefined`.
+ *
+ * `AppshellPlugin` cannot inject this itself — `ModuleFederationPlugin` reads its own
+ * options during its `apply`, which webpack has already run by the time it reaches ours.
+ * Spread into your own config, it sidesteps plugin ordering entirely:
+ *
+ * ```js
+ * const { appshellShared } = require('@appshell/webpack-plugin');
+ * const { dependencies } = require('./package.json');
+ *
+ * new ModuleFederationPlugin({
+ *   shared: appshellShared({ react: true, dependencies }),
+ * });
+ * ```
+ */
+export declare const appshellShared: ({ react, dependencies, extra, }?: AppshellSharedOptions) => SharedObject;
+export default appshellShared;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appshell/webpack-plugin",
-  "version": "1.0.0-alpha.24",
+  "version": "1.0.0-alpha.25",
   "description": "Webpack plugin used to generate a global Appshell configuration for micro-frontends built with Module Federation",
   "main": "dist/main.js",
   "types": "dist/types/webpack-plugin/src/index.d.ts",
@@ -32,8 +32,8 @@
     "plugin"
   ],
   "license": "MIT",
-  "gitHead": "41f2ce7eee90490c80273dfe4a5df46295730a0e",
+  "gitHead": "7d90eb91be3cb50aae5aaa680063878dfcaafea2",
   "dependencies": {
-    "@appshell/tokens": "^1.0.0-alpha.24"
+    "@appshell/tokens": "^1.0.0-alpha.25"
   }
 }