@appshell/loader 1.0.0-alpha.10 → 1.0.0-alpha.101

package/src/remoteLoader.ts

@@ -1,80 +0,0 @@
-/* eslint-disable no-underscore-dangle */
-import type { AppshellComposition, AppshellGlobalConfig } from '@appshell/config';
-import fetchDynamicScript from './fetchDynamicScript';
-import loadAppshellComponent from './loadAppshellComponent';
-import {
-  chainResolvers,
-  inlineResolver,
-  legacyManifestResolver,
-  registryResolver,
-  type RemoteResolver,
-} from './resolvers';
-
-const fetchedScriptCache = new Set<string>();
-
-declare global {
-  interface Window {
-    __appshell_config__?: AppshellComposition;
-  }
-}
-
-export type RemoteLoaderOptions = {
-  composition?: AppshellComposition;
-  /** Replaces the resolver chain outright; a seam for tests and embedders. */
-  resolver?: RemoteResolver;
-};
-
-export default (config: AppshellGlobalConfig, options: RemoteLoaderOptions = {}) => {
-  const composition =
-    options.composition ?? (typeof window === 'undefined' ? undefined : window.__appshell_config__);
-
-  const resolve =
-    options.resolver ??
-    chainResolvers(
-      inlineResolver(composition),
-      registryResolver(composition),
-      legacyManifestResolver(config),
-    );
-
-  return async <TComponent>(key: string) => {
-    const failed = (err: unknown) =>
-      new Error(`Failed to load component '${key}'. ${err?.toString()}`);
-
-    let resolution;
-    try {
-      resolution = await resolve(key);
-    } catch (err) {
-      throw failed(err);
-    }
-
-    if (!resolution) {
-      throw new Error(`Remote resource not found in registry. Expected: ${key}`);
-    }
-
-    const { remote, environment, manifest } = resolution;
-
-    try {
-      window[`__appshell_env__${remote.scope}`] = environment;
-
-      const loaded =
-        fetchedScriptCache.has(remote.remoteEntryUrl) ||
-        (await fetchDynamicScript(remote.remoteEntryUrl));
-
-      if (!loaded) {
-        return [null, null] as const;
-      }
-
-      fetchedScriptCache.add(remote.remoteEntryUrl);
-
-      const Component = await loadAppshellComponent<TComponent>(
-        remote.scope,
-        remote.module,
-        remote.shareScope,
-      );
-
-      return [Component, manifest] as const;
-    } catch (err) {
-      throw failed(err);
-    }
-  };
-};

package/src/resolvers.ts

@@ -1,110 +0,0 @@
-import type {
-  AppshellComposition,
-  AppshellGlobalConfig,
-  AppshellManifest,
-  ResolvedRemote,
-} from '@appshell/config';
-
-export type RemoteResolution = {
-  remote: ResolvedRemote;
-  /** Already merged with the environment's overrides — nothing left for the browser to layer on. */
-  environment: Record<string, string | number | undefined>;
-  /** Back-compat payload for `ManifestProvider`; synthesized when the source was a composition. */
-  manifest: AppshellManifest;
-};
-
-export type RemoteResolver = (key: string) => Promise<RemoteResolution | undefined>;
-
-const manifestOf = (composition: AppshellComposition, remotes: AppshellManifest['remotes']) => ({
-  remotes,
-  environment: composition.environment,
-  modules: {},
-});
-
-/** The registry inlined the composition into the page, so no network call is needed. */
-export const inlineResolver =
-  (composition?: AppshellComposition): RemoteResolver =>
-  async (key) => {
-    const remote = composition?.remotes[key];
-    if (!composition || !remote) return undefined;
-
-    return {
-      remote,
-      environment: composition.environment[remote.scope] ?? {},
-      manifest: manifestOf(composition, composition.remotes),
-    };
-  };
-
-/** Fetch-on-miss: covers an app activated after this page was served. */
-export const registryResolver =
-  (composition?: AppshellComposition, origin = ''): RemoteResolver =>
-  async (key) => {
-    if (!composition) return undefined;
-
-    const url = `${origin}/v1/environments/${composition.environmentId}/remotes/${key}`;
-    const response = await fetch(url, { credentials: 'include' });
-    if (!response.ok) return undefined;
-
-    const remote: ResolvedRemote = await response.json();
-
-    return {
-      remote,
-      environment: composition.environment[remote.scope] ?? {},
-      manifest: manifestOf(composition, { [key]: remote }),
-    };
-  };
-
-/**
- * Pre-registry hosts: follow `index[key]` to the app's own manifest. The override
- * merge stays here because in this mode no server has done it.
- */
-export const legacyManifestResolver = (config: AppshellGlobalConfig): RemoteResolver => {
-  const cache = new Map<string, Promise<AppshellManifest>>();
-
-  const fetchManifest = (url: string) => {
-    const cached = cache.get(url);
-    if (cached) return cached;
-
-    const pending = fetch(url, { credentials: 'include' }).then(async (response) => {
-      if (!response.ok) {
-        throw new Error(`Failed to get manifest from ${url}. ${await response.text()}`);
-      }
-      return response.json() as Promise<AppshellManifest>;
-    });
-
-    cache.set(url, pending);
-
-    return pending;
-  };
-
-  return async (key) => {
-    const manifestUrl = config.index?.[key];
-    if (!manifestUrl) return undefined;
-
-    const manifest = await fetchManifest(manifestUrl);
-    const remote = manifest?.remotes[key];
-    if (!remote) return undefined;
-
-    return {
-      remote,
-      environment: {
-        ...(manifest.environment[remote.scope] ?? {}),
-        ...(config.overrides?.environment?.[remote.scope] ?? {}),
-      },
-      manifest,
-    };
-  };
-};
-
-export const chainResolvers =
-  (...resolvers: RemoteResolver[]): RemoteResolver =>
-  async (key) => {
-    // eslint-disable-next-line no-restricted-syntax
-    for (const resolve of resolvers) {
-      // eslint-disable-next-line no-await-in-loop
-      const resolution = await resolve(key);
-      if (resolution) return resolution;
-    }
-
-    return undefined;
-  };

package/src/types.ts

@@ -1,10 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type ShareScope<TComponent = any> = Record<
-  string,
-  Record<string, { loaded?: 1; get: () => Promise<TComponent>; from: string; eager: boolean }>
->;
-
-export interface ModuleContainer<TComponent> {
-  init(shareScope: ShareScope<TComponent>): Promise<void>;
-  get(module: string): Promise<() => Record<string, TComponent>>;
-}

package/tsconfig.json

@@ -1,7 +0,0 @@
-{
-  "extends": "../../tsconfig",
-  "compilerOptions": {
-    "declarationDir": "./dist/types"
-  },
-  "include": ["./src"]
-}

package/webpack.config.js

@@ -1,37 +0,0 @@
-const path = require('path');
-const TsconfigPathsPlugin = require('tsconfig-paths-webpack-plugin');
-
-module.exports = (env, { mode }) => {
-  const isDevelopment = mode === 'development';
-
-  return {
-    entry: './src/index',
-    mode,
-    devtool: isDevelopment ? 'eval-source-map' : false,
-    output: {
-      filename: '[name].js',
-      pathinfo: false,
-      libraryTarget: 'umd',
-    },
-    resolve: {
-      extensions: ['.js', '.ts'],
-      plugins: [new TsconfigPathsPlugin()],
-    },
-    module: {
-      rules: [
-        {
-          test: /\.ts$/,
-          exclude: /node_modules/,
-          use: [
-            {
-              loader: 'babel-loader',
-              options: {
-                presets: ['@babel/preset-typescript'],
-              },
-            },
-          ],
-        },
-      ],
-    },
-  };
-};