@backtickjs/core 0.2.0 → 0.2.2

package/README.md

@@ -58,6 +58,56 @@ import { greet } from "my-native-module" with { backtick: "client" };
 
 The package must be installed where the server's file finds it, for its types and its version. The client must provide it, and the server must list it in the bundler's `modules` at that version or a later one of the same major. The compiler writes each name as what `createImport({ name, from, version })` makes, which a hand-written import can call too.
 
+To draw for clients on two majors of a package, install both, one under an alias: `"acme-ui-2": "npm:acme-ui@2"`. An import from either is of `acme-ui`, the module clients provide, typed against its own version; `supports`, in a server component, picks the one the client can run:
+
+```ts
+import { Button } from "acme-ui" with { backtick: "client" };
+import { Button as Button2 } from "acme-ui-2" with { backtick: "client" };
+
+function Save() {
+  return supports("acme-ui", "^2.0.0")
+    ? cs`<$Button2 tone="primary">Save</$Button2>`
+    : cs`<$Button variant="primary">Save</$Button>`;
+}
+```
+
+## Every build in users' hands
+
+A store build carries the modules it was built with, at their versions, for as long as it's installed, while your server moves on. Each build sends the modules it carries, and the server bundles its screens for exactly those: there's nothing to record before a build ships, and any version of your server can draw for any build.
+
+1. **The app's module map** offers what screens may require, each from a package in `package.json`'s dependencies. A platform that differs gets its own file, as Metro picks files: `client/moduleMap.web.ts` for the web.
+
+2. **The app's build records its installed packages.** `installedPackages`, from `@backtickjs/core/node`, reads the installed version of each of the app's dependencies from `node_modules`, and the build embeds them in the app. In an Expo app, the config plugin from [`@backtickjs/expo`](https://github.com/backtickjs/backtick/tree/main/packages/expo) does it:
+
+   ```json
+   // app.json
+   { "expo": { "plugins": ["@backtickjs/expo"] } }
+   ```
+
+3. **The app sends its modules** however it reaches its server: a header, a GraphQL variable. `modulesOf` gives each module in the map its package's version, and throws as the app starts for a module from a package that isn't a dependency:
+
+   ```ts
+   import { modulesOf } from "@backtickjs/core";
+   import { getBacktickExtra } from "@backtickjs/expo";
+
+   const { installedPackages } = getBacktickExtra(Constants.expoConfig);
+   const modules = JSON.stringify(modulesOf(moduleMap, installedPackages));
+   fetch(url, { headers: { "x-backtick-modules": modules } });
+   ```
+
+4. **The server bundles for them:**
+
+   ```ts
+   const modules = JSON.parse(context.req.header("x-backtick-modules") ?? "{}");
+   const bundle = await bundler.build({ input, modules });
+   ```
+
+   The bundler refuses modules that aren't `{ "specifier": "version" }`, and a screen that imports a module the build doesn't carry, or at a version it can't run. To draw differently for builds that lack a module, or to ask old ones to update, check with `supports` from [`@backtickjs/bundler`](https://github.com/backtickjs/backtick/tree/main/packages/bundler), in a server component: `supports("react-native", ">=0.86")`.
+
+In development, a reload keeps the app config the app was opened with, and its versions with it: after upgrading a package, close the app and open it again.
+
+A test draws a screen with a module map of its own, stand-ins included; its modules are that map's, at the versions the app installs: `modulesOf(moduleMap, installedPackages(projectRoot))`.
+
 ## API
 
 - `cs`: the tag for client scripts. Compiled at build time; throws if called uncompiled.
@@ -70,6 +120,8 @@ The package must be installed where the server's file finds it, for its types an
 - `Bundle<T>`: a bundle's code, branded with what it runs to. `bundler.build(…).generate(…)` writes one.
 - `execRoot(bundle, moduleMap)`, from `@backtickjs/core/cjs`: in a React Native app, runs the CommonJS bundle it starts from to its value, as a promise, with `require` answered from `moduleMap`, a `ModuleMap`: the modules the app provides, by specifier.
 - `execRoot(bundle)`, from `@backtickjs/core/es`: in a web page, imports the ES bundle it starts from and resolves to its value, the page's import map answering its imports. Each format has its own entry, so a React Native app's bundler never reads the ES one's `import()`.
+- `modulesOf(moduleMap, installedPackages)`: the modules `moduleMap`, a `ModuleMap`, offers, each at its package's version in `installedPackages`, for the app to send its server.
+- `installedPackages(projectRoot)`, from `@backtickjs/core/node`: the installed version of each of the app's dependencies, read from `node_modules` as Metro finds packages by default. A `metro.config.js` that aliases or redirects packages needs its own versions. Node only.
 - `exec`: in a script, `$exec(bundle)` runs another bundle as the script's own was run, with the same modules, to a promise of its value.
 - `isClientExec`, `ClientExec`: its check and type.
 - `SplicesAs<T>`: `T` as a splice checks it, member by member. Used by the bundler to check its input.

package/dist/cjs.d.ts

@@ -1,6 +1,5 @@
 import type { Bundle } from "./Bundle.js";
-import type { ModuleMap } from "./ModuleMap.js";
-export type { ModuleMap };
+import type { ModuleMap } from "./modulesOf.js";
 /**
  * Executes a CommonJS bundle an app starts from, the one nothing else runs,
  * to its value, with `require` answered from `moduleMap`: how a React Native

package/dist/cjs.js.map

@@ -1 +1 @@
-{"version":3,"file":"cjs.js","sourceRoot":"","sources":["../src/cjs.ts"],"names":[],"mappings":"AAKA;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,QAAQ,CAC5B,MAAiB,EACjB,SAAoB;IAEpB,MAAM,OAAO,GAAG,CAAC,SAAiB,EAAW,EAAE;QAC7C,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,SAAS,CAAC,EAAE,CAAC;YACzC,MAAM,IAAI,KAAK,CACb,wBAAwB,SAAS,oCAAoC,CACtE,CAAC;QACJ,CAAC;QACD,OAAO,SAAS,CAAC,SAAS,CAAC,CAAC;IAC9B,CAAC,CAAC;IACF,MAAM,MAAM,GAAG,EAAE,OAAO,EAAE,EAAa,EAAE,CAAC;IAC1C,IAAI,QAAQ,CAAC,QAAQ,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,CAAC,CAClD,MAAM,EACN,MAAM,CAAC,OAAO,EACd,OAAO,CACR,CAAC;IACF,OAAO,MAAM,CAAC,OAAqB,CAAC;AACtC,CAAC"}
+{"version":3,"file":"cjs.js","sourceRoot":"","sources":["../src/cjs.ts"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,QAAQ,CAC5B,MAAiB,EACjB,SAAoB;IAEpB,MAAM,OAAO,GAAG,CAAC,SAAiB,EAAW,EAAE;QAC7C,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,SAAS,CAAC,EAAE,CAAC;YACzC,MAAM,IAAI,KAAK,CACb,wBAAwB,SAAS,oCAAoC,CACtE,CAAC;QACJ,CAAC;QACD,OAAO,SAAS,CAAC,SAAS,CAAC,CAAC;IAC9B,CAAC,CAAC;IACF,MAAM,MAAM,GAAG,EAAE,OAAO,EAAE,EAAa,EAAE,CAAC;IAC1C,IAAI,QAAQ,CAAC,QAAQ,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,CAAC,CAClD,MAAM,EACN,MAAM,CAAC,OAAO,EACd,OAAO,CACR,CAAC;IACF,OAAO,MAAM,CAAC,OAAqB,CAAC;AACtC,CAAC"}

package/dist/index.d.ts

@@ -12,3 +12,4 @@ export type { Bundle } from "./Bundle.js";
 export { exec, isClientExec, type ClientExec } from "./exec.js";
 export { createJsxElement, isJsxElement, type JsxElement, type JsxElementOf, type JsxElementTypeOf, } from "./JsxElement.js";
 export { create, type ScriptModule, type ClientScript, isClientScript, type Param, } from "./ClientScript.js";
+export { modulesOf, type ModuleMap } from "./modulesOf.js";

package/dist/index.js

@@ -14,4 +14,7 @@ export { createJsxElement, isJsxElement, } from "./JsxElement.js";
 // What a template compiles to: the compiler writes one and the bundler reads
 // it, so the shape is neither end's.
 export { create, isClientScript, } from "./ClientScript.js";
+// What an app provides bundles, and what it sends its server for them: the
+// modules it offers, at its packages' versions.
+export { modulesOf } from "./modulesOf.js";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,4EAA4E;AAC5E,wCAAwC;AACxC,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAE7B,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAKjC,OAAO,EACL,YAAY,EACZ,cAAc,GAEf,MAAM,mBAAmB,CAAC;AAM3B,OAAO,EAAE,IAAI,EAAE,YAAY,EAAmB,MAAM,WAAW,CAAC;AAEhE,0EAA0E;AAC1E,4BAA4B;AAC5B,OAAO,EACL,gBAAgB,EAChB,YAAY,GAIb,MAAM,iBAAiB,CAAC;AAEzB,6EAA6E;AAC7E,qCAAqC;AACrC,OAAO,EACL,MAAM,EAGN,cAAc,GAEf,MAAM,mBAAmB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,4EAA4E;AAC5E,wCAAwC;AACxC,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAE7B,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAKjC,OAAO,EACL,YAAY,EACZ,cAAc,GAEf,MAAM,mBAAmB,CAAC;AAM3B,OAAO,EAAE,IAAI,EAAE,YAAY,EAAmB,MAAM,WAAW,CAAC;AAEhE,0EAA0E;AAC1E,4BAA4B;AAC5B,OAAO,EACL,gBAAgB,EAChB,YAAY,GAIb,MAAM,iBAAiB,CAAC;AAEzB,6EAA6E;AAC7E,qCAAqC;AACrC,OAAO,EACL,MAAM,EAGN,cAAc,GAEf,MAAM,mBAAmB,CAAC;AAE3B,2EAA2E;AAC3E,gDAAgD;AAChD,OAAO,EAAE,SAAS,EAAkB,MAAM,gBAAgB,CAAC"}

package/dist/modulesOf.d.ts

@@ -0,0 +1,27 @@
+/**
+ * What a bundle may import, by specifier: each the module the app imported
+ * for it. What a web page's import map does, for an app, with modules for
+ * values instead of URLs:
+ *
+ *     import * as React from "react";
+ *     import * as JSXRuntime from "react/jsx-runtime";
+ *     import * as ReactNative from "react-native";
+ *
+ *     export const moduleMap = {
+ *       react: React,
+ *       "react/jsx-runtime": JSXRuntime,
+ *       "react-native": ReactNative,
+ *     };
+ */
+export type ModuleMap = Readonly<Record<string, unknown>>;
+/**
+ * The modules `moduleMap` offers, each at the version in `installedPackages`
+ * of the package it comes from: what the app sends however it reaches its
+ * server, a header, a GraphQL variable, for the server to bundle screens it
+ * can run. The app's build records them, with `installedPackages` from
+ * `@backtickjs/core/node`. Throws as the app starts for a module from a
+ * package that isn't a dependency.
+ *
+ *     const modules = modulesOf(moduleMap, installedPackages);
+ */
+export declare function modulesOf(moduleMap: ModuleMap, installedPackages: Readonly<Record<string, string>>): Record<string, string>;

package/dist/modulesOf.js

@@ -0,0 +1,25 @@
+// The package a module specifier is in: `react` for `react/jsx-runtime`.
+function packageOf(specifier) {
+    const segments = specifier.split("/");
+    return segments.slice(0, specifier.startsWith("@") ? 2 : 1).join("/");
+}
+/**
+ * The modules `moduleMap` offers, each at the version in `installedPackages`
+ * of the package it comes from: what the app sends however it reaches its
+ * server, a header, a GraphQL variable, for the server to bundle screens it
+ * can run. The app's build records them, with `installedPackages` from
+ * `@backtickjs/core/node`. Throws as the app starts for a module from a
+ * package that isn't a dependency.
+ *
+ *     const modules = modulesOf(moduleMap, installedPackages);
+ */
+export function modulesOf(moduleMap, installedPackages) {
+    return Object.fromEntries(Object.keys(moduleMap).map((specifier) => {
+        const version = installedPackages[packageOf(specifier)];
+        if (version === undefined) {
+            throw new Error(`The module map offers ${JSON.stringify(specifier)}, but ${packageOf(specifier)} isn't in package.json's dependencies.`);
+        }
+        return [specifier, version];
+    }));
+}
+//# sourceMappingURL=modulesOf.js.map

package/dist/modulesOf.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"modulesOf.js","sourceRoot":"","sources":["../src/modulesOf.ts"],"names":[],"mappings":"AAiBA,yEAAyE;AACzE,SAAS,SAAS,CAAC,SAAiB;IAClC,MAAM,QAAQ,GAAG,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACtC,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,SAAS,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AACxE,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,SAAS,CACvB,SAAoB,EACpB,iBAAmD;IAEnD,OAAO,MAAM,CAAC,WAAW,CACvB,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE;QACvC,MAAM,OAAO,GAAG,iBAAiB,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,CAAC;QACxD,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;YAC1B,MAAM,IAAI,KAAK,CACb,yBAAyB,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,SAAS,SAAS,CAAC,SAAS,CAAC,wCAAwC,CACxH,CAAC;QACJ,CAAC;QACD,OAAO,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;IAC9B,CAAC,CAAC,CACH,CAAC;AACJ,CAAC"}

package/dist/node.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The installed version of each of the app's dependencies, at `projectRoot`:
+ * what a build made from it now carries there, for `modulesOf`. Node only:
+ * the app's build calls it, and embeds what it answers in the app.
+ * Packages are found as Metro finds them by default, in `node_modules` here
+ * or above: a `metro.config.js` that aliases or redirects them needs its own
+ * versions.
+ */
+export declare function installedPackages(projectRoot: string): Record<string, string>;

package/dist/node.js

@@ -0,0 +1,30 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+// Where a package is installed for the app at `projectRoot`, as Node finds
+// it: in its node_modules, or the nearest above, as a workspace hoists it.
+function installed(projectRoot, name) {
+    for (let directory = projectRoot;; directory = dirname(directory)) {
+        const file = join(directory, "node_modules", name, "package.json");
+        if (existsSync(file))
+            return file;
+        if (dirname(directory) === directory) {
+            throw new Error(`${projectRoot}: ${name} isn't installed`);
+        }
+    }
+}
+/**
+ * The installed version of each of the app's dependencies, at `projectRoot`:
+ * what a build made from it now carries there, for `modulesOf`. Node only:
+ * the app's build calls it, and embeds what it answers in the app.
+ * Packages are found as Metro finds them by default, in `node_modules` here
+ * or above: a `metro.config.js` that aliases or redirects them needs its own
+ * versions.
+ */
+export function installedPackages(projectRoot) {
+    const { dependencies = {} } = JSON.parse(readFileSync(join(projectRoot, "package.json"), "utf8"));
+    return Object.fromEntries(Object.keys(dependencies).map((name) => [
+        name,
+        JSON.parse(readFileSync(installed(projectRoot, name), "utf8")).version,
+    ]));
+}
+//# sourceMappingURL=node.js.map

package/dist/node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.js","sourceRoot":"","sources":["../src/node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACnD,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAE1C,2EAA2E;AAC3E,2EAA2E;AAC3E,SAAS,SAAS,CAAC,WAAmB,EAAE,IAAY;IAClD,KAAK,IAAI,SAAS,GAAG,WAAW,GAAI,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC;QACnE,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,EAAE,cAAc,EAAE,IAAI,EAAE,cAAc,CAAC,CAAC;QACnE,IAAI,UAAU,CAAC,IAAI,CAAC;YAAE,OAAO,IAAI,CAAC;QAClC,IAAI,OAAO,CAAC,SAAS,CAAC,KAAK,SAAS,EAAE,CAAC;YACrC,MAAM,IAAI,KAAK,CAAC,GAAG,WAAW,KAAK,IAAI,kBAAkB,CAAC,CAAC;QAC7D,CAAC;IACH,CAAC;AACH,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,iBAAiB,CAAC,WAAmB;IACnD,MAAM,EAAE,YAAY,GAAG,EAAE,EAAE,GAAG,IAAI,CAAC,KAAK,CACtC,YAAY,CAAC,IAAI,CAAC,WAAW,EAAE,cAAc,CAAC,EAAE,MAAM,CAAC,CACX,CAAC;IAC/C,OAAO,MAAM,CAAC,WAAW,CACvB,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC;QACtC,IAAI;QAEF,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,SAAS,CAAC,WAAW,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,CAG9D,CAAC,OAAO;KACV,CAAC,CACH,CAAC;AACJ,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@backtickjs/core",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "The cs tag for Backtick client scripts, and the types for the values that cross from server to client",
   "keywords": [
     "backtick",
@@ -36,6 +36,10 @@
     "./es": {
       "types": "./dist/es.d.ts",
       "default": "./dist/es.js"
+    },
+    "./node": {
+      "types": "./dist/node.d.ts",
+      "default": "./dist/node.js"
     }
   },
   "files": [

package/src/cjs.ts

@@ -1,7 +1,5 @@
 import type { Bundle } from "./Bundle.js";
-import type { ModuleMap } from "./ModuleMap.js";
-
-export type { ModuleMap };
+import type { ModuleMap } from "./modulesOf.js";
 
 /**
  * Executes a CommonJS bundle an app starts from, the one nothing else runs,

package/src/index.ts

@@ -43,3 +43,7 @@ export {
   isClientScript,
   type Param,
 } from "./ClientScript.js";
+
+// What an app provides bundles, and what it sends its server for them: the
+// modules it offers, at its packages' versions.
+export { modulesOf, type ModuleMap } from "./modulesOf.js";

package/src/modulesOf.ts

@@ -0,0 +1,49 @@
+/**
+ * What a bundle may import, by specifier: each the module the app imported
+ * for it. What a web page's import map does, for an app, with modules for
+ * values instead of URLs:
+ *
+ *     import * as React from "react";
+ *     import * as JSXRuntime from "react/jsx-runtime";
+ *     import * as ReactNative from "react-native";
+ *
+ *     export const moduleMap = {
+ *       react: React,
+ *       "react/jsx-runtime": JSXRuntime,
+ *       "react-native": ReactNative,
+ *     };
+ */
+export type ModuleMap = Readonly<Record<string, unknown>>;
+
+// The package a module specifier is in: `react` for `react/jsx-runtime`.
+function packageOf(specifier: string): string {
+  const segments = specifier.split("/");
+  return segments.slice(0, specifier.startsWith("@") ? 2 : 1).join("/");
+}
+
+/**
+ * The modules `moduleMap` offers, each at the version in `installedPackages`
+ * of the package it comes from: what the app sends however it reaches its
+ * server, a header, a GraphQL variable, for the server to bundle screens it
+ * can run. The app's build records them, with `installedPackages` from
+ * `@backtickjs/core/node`. Throws as the app starts for a module from a
+ * package that isn't a dependency.
+ *
+ *     const modules = modulesOf(moduleMap, installedPackages);
+ */
+export function modulesOf(
+  moduleMap: ModuleMap,
+  installedPackages: Readonly<Record<string, string>>,
+): Record<string, string> {
+  return Object.fromEntries(
+    Object.keys(moduleMap).map((specifier) => {
+      const version = installedPackages[packageOf(specifier)];
+      if (version === undefined) {
+        throw new Error(
+          `The module map offers ${JSON.stringify(specifier)}, but ${packageOf(specifier)} isn't in package.json's dependencies.`,
+        );
+      }
+      return [specifier, version];
+    }),
+  );
+}

package/src/node.ts

@@ -0,0 +1,38 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+// Where a package is installed for the app at `projectRoot`, as Node finds
+// it: in its node_modules, or the nearest above, as a workspace hoists it.
+function installed(projectRoot: string, name: string): string {
+  for (let directory = projectRoot; ; directory = dirname(directory)) {
+    const file = join(directory, "node_modules", name, "package.json");
+    if (existsSync(file)) return file;
+    if (dirname(directory) === directory) {
+      throw new Error(`${projectRoot}: ${name} isn't installed`);
+    }
+  }
+}
+
+/**
+ * The installed version of each of the app's dependencies, at `projectRoot`:
+ * what a build made from it now carries there, for `modulesOf`. Node only:
+ * the app's build calls it, and embeds what it answers in the app.
+ * Packages are found as Metro finds them by default, in `node_modules` here
+ * or above: a `metro.config.js` that aliases or redirects them needs its own
+ * versions.
+ */
+export function installedPackages(projectRoot: string): Record<string, string> {
+  const { dependencies = {} } = JSON.parse(
+    readFileSync(join(projectRoot, "package.json"), "utf8"),
+  ) as { dependencies?: Record<string, string> };
+  return Object.fromEntries(
+    Object.keys(dependencies).map((name) => [
+      name,
+      (
+        JSON.parse(readFileSync(installed(projectRoot, name), "utf8")) as {
+          version: string;
+        }
+      ).version,
+    ]),
+  );
+}

package/dist/ModuleMap.d.ts

@@ -1,16 +0,0 @@
-/**
- * What a bundle may import, by specifier: each the module the app imported
- * for it. What a web page's import map does, for an app, with modules for
- * values instead of URLs:
- *
- *     import * as React from "react";
- *     import * as JSXRuntime from "react/jsx-runtime";
- *     import * as ReactNative from "react-native";
- *
- *     export const moduleMap = {
- *       react: React,
- *       "react/jsx-runtime": JSXRuntime,
- *       "react-native": ReactNative,
- *     };
- */
-export type ModuleMap = Readonly<Record<string, unknown>>;

package/dist/ModuleMap.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=ModuleMap.js.map

package/dist/ModuleMap.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ModuleMap.js","sourceRoot":"","sources":["../src/ModuleMap.ts"],"names":[],"mappings":""}

package/src/ModuleMap.ts

@@ -1,16 +0,0 @@
-/**
- * What a bundle may import, by specifier: each the module the app imported
- * for it. What a web page's import map does, for an app, with modules for
- * values instead of URLs:
- *
- *     import * as React from "react";
- *     import * as JSXRuntime from "react/jsx-runtime";
- *     import * as ReactNative from "react-native";
- *
- *     export const moduleMap = {
- *       react: React,
- *       "react/jsx-runtime": JSXRuntime,
- *       "react-native": ReactNative,
- *     };
- */
-export type ModuleMap = Readonly<Record<string, unknown>>;