@appshell/runtime 1.0.0-alpha.15

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Navaris Technologies, LLC
+
+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,54 @@
+# @appshell/runtime
+
+The store that delivers a package's runtime configuration (`vars`) to it.
+
+This is a **shared singleton**. There is exactly one instance per page, held in the
+module federation share scope, and both the host and every package must declare it as
+such. It replaced `window.__appshell_vars__<scope>`.
+
+Most packages should not import this directly — use
+[`@appshell/vars`](../vars/README.md), which supplies the scope for you.
+
+## Contract
+
+```ts
+setVars(scope, vars); // the host, immediately before loading a remote
+readVars(scope); // a package, reading its own configuration
+hasVars(scope); // branch instead of catch
+```
+
+`@appshell/loader` calls `setVars` before it loads a remote, so a package's vars are in
+place before its modules evaluate — including a read at module-eval time.
+
+The first write for a scope wins and is frozen. Re-delivering the identical vars is a
+no-op, because the same remote can be mounted more than once; replacing them throws
+`VarsConflictError`.
+
+`readVars` throws `MissingVarsError` rather than returning an empty object. A package
+that silently renders with no configuration is the failure this replaced.
+
+## What this does and does not fix
+
+Against the global it replaced, it fixes: unbounded, never-cleaned-up keys; silent
+cross-package overwrite; the load-order coupling between host and remote; and being
+untyped and undiscoverable.
+
+It **does not make a scope's vars private.** Any code on the page can call
+`readVars('SomeOtherScope')`, and a package that loads early can squat on a scope that
+has not been delivered yet. Nothing short of a separate realm — an iframe, a worker —
+would change that, and none of this is a security boundary. Do not put a secret in
+`vars`; the registry serves them to the browser in the composition either way.
+
+## Setup
+
+Both sides declare it, or each ends up with its own empty store:
+
+```js
+new ModuleFederationPlugin({
+  shared: {
+    '@appshell/runtime': { singleton: true },
+  },
+});
+```
+
+`AppshellPlugin` fails the build when a package omits it.

package/dist/main.js

@@ -0,0 +1 @@
+!function(e,r){if("object"==typeof exports&&"object"==typeof module)module.exports=r();else if("function"==typeof define&&define.amd)define([],r);else{var t=r();for(var s in t)("object"==typeof exports?exports:e)[s]=t[s]}}(self,(()=>(()=>{"use strict";var e={d:(r,t)=>{for(var s in t)e.o(t,s)&&!e.o(r,s)&&Object.defineProperty(r,s,{enumerable:!0,get:t[s]})},o:(e,r)=>Object.prototype.hasOwnProperty.call(e,r),r:e=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})}},r={};e.r(r),e.d(r,{MissingVarsError:()=>t,VarsConflictError:()=>s,hasVars:()=>i,readVars:()=>n,resetVars:()=>c,setVars:()=>a});class t extends Error{constructor(e,r){super(`No vars were delivered for '${e}'. ${r.length?`Vars are present for ${r.map((e=>`'${e}'`)).join(", ")} — check that '${e}' matches the module federation name the registry knows this package by.`:"Nothing has delivered vars on this page — check that the host and this package both declare '@appshell/runtime' as a shared singleton."}`),this.name="MissingVarsError",this.scope=e}}class s extends Error{constructor(e){super(`Vars for '${e}' were already delivered and cannot be replaced. A scope receives its vars once per page load.`),this.name="VarsConflictError",this.scope=e}}const o=new Map,a=(e,r)=>{const t=o.get(e);var a,n;if(t){if(a=t,n=r,![...new Set([...Object.keys(a),...Object.keys(n)])].every((e=>a[e]===n[e])))throw new s(e)}else o.set(e,Object.freeze({...r}))},n=e=>{const r=o.get(e);if(!r)throw new t(e,[...o.keys()]);return r},i=e=>o.has(e),c=()=>{o.clear()};return r})()));

package/dist/types/errors.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/types/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/errors.ts"],"names":[],"mappings":"AACA;;;;;;;;GAQG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;IACzC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;gBAEX,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE;CAc3C;AAED;;;;;;;GAOG;AACH,qBAAa,iBAAkB,SAAQ,KAAK;IAC1C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;gBAEX,KAAK,EAAE,MAAM;CAS1B"}

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+export { MissingVarsError, VarsConflictError } from './errors';
+export { hasVars, readVars, resetVars, setVars } from './store';
+export type { Vars } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC/D,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAChE,YAAY,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC"}

package/dist/types/store.d.ts

@@ -0,0 +1,26 @@
+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/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;
+//# sourceMappingURL=store.d.ts.map

package/dist/types/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAepC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,OAAO,UAAW,MAAM,QAAQ,IAAI,KAAG,IAYnD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,GAAI,KAAK,SAAS,IAAI,gBAAgB,MAAM,KAAG,KAQnE,CAAC;AAEF,4FAA4F;AAC5F,eAAO,MAAM,OAAO,UAAW,MAAM,KAAG,OAA+B,CAAC;AAExE,qEAAqE;AACrE,eAAO,MAAM,SAAS,QAAO,IAE5B,CAAC"}

package/dist/types/types.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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>;
+//# sourceMappingURL=types.d.ts.map

package/dist/types/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC,CAAC"}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@appshell/runtime",
+  "version": "1.0.0-alpha.15",
+  "description": "The shared singleton that delivers a package's runtime configuration to it",
+  "main": "dist/main.js",
+  "types": "dist/types/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/appshellhq/appshell.git"
+  },
+  "author": "Robert Hamilton <rh@navaris.com>",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "webpack --mode production && npm run build:types",
+    "build:types": "tsc --emitDeclarationOnly",
+    "clean": "rm -rf dist",
+    "prebuild": "npm run clean",
+    "start": "webpack --watch --mode development && npm run build:types",
+    "stats": "webpack --json > stats.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "module federation",
+    "micro-frontends",
+    "appshell"
+  ],
+  "license": "MIT"
+}