@wildo-ai/saas-frontend-lib 1.1.5 → 1.1.7

package/dist/esm/core/components-registry/provider-component-registry.frontend.service.d.ts

@@ -1,243 +1,43 @@
 /**
- * Components contributed by PROVIDERS, keyed by the capability each fills.
- *
- * ## Why this is a sibling of `ComponentRegistryService` and not an extension
- *
- * The two answer different questions, and the difference is in the KEY, the
- * cardinality and the lifecycle — not in whether a vocabulary is open:
- *
- *   - `ComponentRegistryService` keys `componentType:preset[:category]`, where
- *     `FrontendComponentType` is a CLOSED enum the engine owns. Exactly one
- *     component answers a key, resolution is synchronous, and a missing
- *     registration is a startup refusal.
- *   - This registry keys `capability:providerRef`. The capability half is
- *     closed too (`ProviderCapability` is the built-in set since #502 removed
- *     module augmentation), but the PROVIDER half is not engine-owned at all:
- *     refs arrive from engine modules, generated packages and application
- *     packages, discovered per deployment. SEVERAL providers may answer one
- *     capability, the component arrives asynchronously, and none of it is
- *     required for the app to mount.
- *
- * Forcing provider components through `FrontendComponentType` would mean an
- * engine enum member per capability and a preset per provider, and would make "which component
- * answers this key" ambiguous in a registry whose whole contract is that it is
- * not. (This paragraph used to justify the split by calling `ProviderCapability`
- * OPEN; that stopped being true with #502, and the split stands on the reasons
- * above.)
- *
- * It also keeps the blast radius honest. `ComponentRegistryService` has sixteen
- * consumers across four packages (re-measured 2026-09-06; the plan's figure of
- * eleven predates several of them), most of them outside this slice's territory.
- * A sibling registry touches none of them.
- *
- * ## Several providers, and no silent winner
- *
- * `listProviders` returns every provider offering a component for a capability,
- * in registration order, and nothing here picks one. That is deliberate: the
- * defect being fixed is that resolution WAS first-match, so a Drive picker and
- * a Dropbox picker could not coexist and the winner depended on map order. A
- * surface with two providers has a choice to present; a registry that answered
- * it would be making a product decision in a lookup table.
+ * The APPLICATION's half of the provider-component registry.
+ *
+ * The registry itself — keyed `capability:providerRef`, consent-gated, script-before-component,
+ * browser-only — lives in `@wildo-ai/external-connectors-public` since #1703, because the website
+ * and the documentation site have to build the same registry from the same `components`
+ * declaration and neither may import this package. Read its module header
+ * (`createProviderComponentRegistry`) for why it is a sibling of `ComponentRegistryService` and why
+ * it never picks a provider.
+ *
+ * What stays here is what only the application has:
+ *
+ *   - the component TYPE the application renders (`ProviderComponent`), which fills the shared
+ *     registry's type parameter;
+ *   - the application's facet-library door, `contributeProviderComponentLoaders`, through which
+ *     `presets-components` supplies loaders for engine-shipped components (#394). It is module-level
+ *     state on purpose: `registerDefaultPresets` runs before `startApplication` builds the registry,
+ *     the same ordering `ComponentRegistryService.register` relies on. The website and the
+ *     documentation site take the same contributions as an explicit input instead, because their
+ *     wiring has a single construction site that can carry it.
  */
 import type React from 'react';
-import type { ProviderCapability } from '@wildo-ai/saas-models';
-import type { ProviderFrontendComponentDescriptor, ProviderFrontendScriptDeclaration } from '@wildo-ai/saas-models/public-runtime';
-import { type DeclaredProviderScript, type ProviderScriptLoadOutcome } from '@wildo-ai/external-connectors-public/app';
-/** A loader as a provider module declares it: on demand, returning the component. */
-export type ProviderComponentLoader = () => Promise<unknown>;
-/** Why a provider component could not be registered or loaded. */
-export declare enum ProviderComponentDiagnosticKind {
-    /**
-     * A second registration arrived for one capability AND provider. The first is
-     * kept: a duplicate is a wiring mistake, and swapping the live component
-     * under a mounted surface would be worse than ignoring it.
-     */
-    DUPLICATE_REGISTRATION = "DUPLICATE_REGISTRATION",
-    /** The loader threw or rejected. That provider's component is unavailable; others are not affected. */
-    LOAD_FAILED = "LOAD_FAILED",
-    /**
-     * The loader resolved something that is not a component. Almost always a
-     * loader returning a MODULE NAMESPACE — `() => import('./Picker')` — where it
-     * should return the component itself.
-     */
-    LOADED_VALUE_IS_NOT_A_COMPONENT = "LOADED_VALUE_IS_NOT_A_COMPONENT",
-    /**
-     * A live provider DECLARES a component for a capability and nothing supplies
-     * its loader — neither the module (`components[cap].load`) nor the facet
-     * library (`contributeProviderComponentLoaders`). The declaration is DATA a
-     * reviewer can read; without code behind it the chooser would offer a picker
-     * that cannot open. Not registered, and reported once at startup.
-     */
-    DECLARED_WITHOUT_LOADER = "DECLARED_WITHOUT_LOADER",
-    /**
-     * BOTH the module and the facet library supplied a loader for one
-     * `capability:providerRef`. The module's wins — it is the provider's own
-     * word — and the collision is reported, because the engine never authors both
-     * and two loaders for one declaration is the map-order ambiguity #380 removed.
-     */
-    LOADER_SUPPLIED_TWICE = "LOADER_SUPPLIED_TWICE",
-    /**
-     * A `<script>` the declaring provider needs did not load — a network failure,
-     * a Content-Security-Policy refusal, or an integrity mismatch. The component
-     * resolves `null`, and that answer is CACHED exactly like `LOAD_FAILED`: the
-     * failed element stays in the document and is not retried this session (a
-     * vendor script can fail after partially executing, and a second copy could
-     * initialise over the first), so a chooser re-rendering must not re-ask. A
-     * component whose vendor global is absent is not usable, and handing it back
-     * would only move the failure into its own mount ("The Google API script has
-     * not loaded"), where nothing can name the provider's declaration as the cause.
-     */
-    SCRIPT_LOAD_FAILED = "SCRIPT_LOAD_FAILED"
-}
-export interface ProviderComponentDiagnostic {
-    readonly kind: ProviderComponentDiagnosticKind;
-    readonly capability: string;
-    readonly providerRef: string;
-    readonly message: string;
-    readonly cause?: unknown;
-}
-export interface ProviderComponentRegistration {
-    readonly capability: ProviderCapability;
-    readonly providerRef: string;
-    readonly load: ProviderComponentLoader;
-    /**
-     * What the provider DECLARED about this component — today, what a selection
-     * from it contains. Kept beside the loader rather than looked up from the
-     * DATA entry at the use site, because a surface needs it BEFORE it decides to
-     * load anything, and because the two would then be two sources for one fact.
-     */
-    readonly descriptor: ProviderFrontendComponentDescriptor;
-    /**
-     * The third-party `<script>` tags the DECLARING PROVIDER needs (its module's
-     * `scripts`), loaded before the component is handed back. Carried on the
-     * registration because a provider's scripts load when its code first runs on
-     * this surface — with its component, when it contributes one — so no page pays
-     * for a vendor loader nobody opened. Absent means the component depends on no
-     * script.
-     */
-    readonly scripts?: ReadonlyArray<ProviderFrontendScriptDeclaration>;
-}
-/**
- * Loads a provider's declared scripts and resolves once each has executed or
- * failed. Never rejects: failures come back in the outcome.
- */
-export type ProviderComponentScriptLoader = (scripts: ReadonlyArray<DeclaredProviderScript>) => Promise<ProviderScriptLoadOutcome>;
-/** A component type this registry will hand back once loaded. */
+import type { ProviderComponentLoaderContribution, ProviderComponentRegistry } from '@wildo-ai/external-connectors-public/app';
+/** A component type the application's registry hands back once loaded. */
 export type ProviderComponent = React.ComponentType<never>;
-export interface ProviderComponentRegistry {
-    /**
-     * Every provider offering a component for this capability, in registration
-     * order. Synchronous ON PURPOSE: a surface has to render its chooser before
-     * any component is loaded, and awaiting here would make an empty frame.
-     */
-    listProviders(capability: ProviderCapability): ReadonlyArray<string>;
-    /** Whether this exact provider offers a component for this capability. */
-    has(capability: ProviderCapability, providerRef: string): boolean;
-    /**
-     * What the provider declared about its component, without loading it —
-     * `undefined` when this provider offers none for this capability.
-     *
-     * Synchronous and separate from `resolve` on purpose: the framework routes a
-     * selection according to what was DECLARED, and a routing decision that had to
-     * await a download would mean downloading a picker to find out whether the
-     * surface can use it.
-     */
-    describe(capability: ProviderCapability, providerRef: string): ProviderFrontendComponentDescriptor | undefined;
-    /**
-     * Loads one provider's component AND the scripts its provider declares, in
-     * parallel, and hands the component back only once both are present — a
-     * component is usable only once what it depends on is. The loader runs at most
-     * once per pair — a chooser that mounts and unmounts must not re-download a
-     * picker — and a failure of either half is reported and returns `null` rather
-     * than throwing into a render.
-     */
-    resolve(capability: ProviderCapability, providerRef: string): Promise<ProviderComponent | null>;
-}
-export declare function createProviderComponentRegistry(input?: {
-    readonly registrations?: Iterable<ProviderComponentRegistration>;
-    readonly onDiagnostic?: (diagnostic: ProviderComponentDiagnostic) => void;
-    /**
-     * How declared scripts are loaded. Defaults to the shared injector on the live
-     * `document`; injectable so a test can settle a script without a network and a
-     * non-DOM host can say what loading means for it.
-     */
-    readonly loadScripts?: ProviderComponentScriptLoader;
-}): ProviderComponentRegistry;
-/** The shape this derivation needs off a hydrated provider module. */
-interface ComponentBearingProviderModule {
-    metadata: {
-        ref: string;
-    };
-    scripts?: ReadonlyArray<ProviderFrontendScriptDeclaration>;
-    components?: Readonly<Record<string, ProviderFrontendComponentDescriptor & {
-        load?: ProviderComponentLoader;
-    }>>;
-}
+/** The application's provider-component registry: the shared registry, holding React components. */
+export type AppProviderComponentRegistry = ProviderComponentRegistry<ProviderComponent>;
 /**
- * A loader the FACET LIBRARY supplies for a component a provider module
- * declares — the second of the two doors, and the one every engine-shipped
- * component uses (#394).
- *
- * The provider module, in `@wildo-ai/external-connectors-public`, declares the
- * DATA half (`components[cap].selectionDelivery`) and cannot name a loader that
- * reaches a React component: that package is deliberately renderer-free, and it
- * sits BELOW the component libraries in the layering, so a dynamic import from
- * it would close a package cycle. The library that owns the component
- * (`presets-components` for the app facet) contributes the loader here instead,
- * from the same place it registers its presets. A provider PACKAGE that ships
- * its own component still uses `components[cap].load` — both doors exist, the
- * engine authors exactly one per declaration, and a collision is reported.
- */
-export interface ProviderComponentLoaderContribution {
-    readonly capability: ProviderCapability;
-    readonly providerRef: string;
-    readonly load: ProviderComponentLoader;
-}
-/**
- * Registers loaders for provider components a facet library ships. Module-level
- * and idempotent per key, like `ComponentRegistryService.register`: the app
- * calls the library's registration entry once at startup, and a second
- * contribution for one key replaces the first rather than duplicating it —
+ * Registers loaders for provider components a facet library ships. Module-level and idempotent per
+ * key, like `ComponentRegistryService.register`: the app calls the library's registration entry once
+ * at startup, and a second contribution for one key replaces the first rather than duplicating it —
  * the library is one author, and the last thing it said is what it means.
  *
- * A contribution for a provider the DATA channel does not declare live is
- * SILENT, by the same rule as code without data in `hydrateFrontendProviderModules`:
- * a bundle legitimately ships a picker an environment leaves off.
+ * A contribution for a provider the DATA channel does not declare live is SILENT, by the same rule
+ * as code without data in `hydrateFrontendProviderModules`: a bundle legitimately ships a picker an
+ * environment leaves off.
  */
 export declare function contributeProviderComponentLoaders(loaders: Iterable<ProviderComponentLoaderContribution>): void;
 /** Every contributed loader, keyed `capability:providerRef`. Read at registry construction. */
 export declare function listContributedProviderComponentLoaders(): ReadonlyMap<string, ProviderComponentLoaderContribution>;
 /** Tests only: forget every contributed loader. */
 export declare function _clearContributedProviderComponentLoaders(): void;
-/**
- * Turns the live provider modules into registrations, joining each declared
- * component to its loader — from the module when it carries one, else from
- * the facet library's contributions.
- *
- * Order follows the registry's iteration order, which is the order the service
- * declared its providers — so `listProviders` is stable across reloads and a
- * surface that shows a chooser does not reorder itself between renders.
- *
- * A declaration nothing can load is NOT registered: a chooser must offer only
- * what can render. It is reported through `onDiagnostic` instead, once, at
- * startup — which is the moment somebody can still fix it.
- */
-export declare function collectProviderComponentRegistrations(modules: Iterable<ComponentBearingProviderModule>, input?: {
-    readonly contributedLoaders?: ReadonlyMap<string, ProviderComponentLoaderContribution>;
-    readonly onDiagnostic?: (diagnostic: ProviderComponentDiagnostic) => void;
-}): ProviderComponentRegistration[];
-/**
- * The scripts a surface must load at STARTUP: those declared by live providers that
- * contribute NO registered component.
- *
- * A provider's scripts load when its code first runs on the surface. A provider with a
- * registered component has that moment — the registry loads its scripts when the
- * component is first resolved, so no page pays for a picker's vendor loader nobody
- * opened. A provider without one never will, so its scripts load at startup, the same
- * population rule SDK activation uses. A provider that DECLARES a component nothing
- * can load is not registered and therefore counts as contributing none: its scripts
- * still load, since whatever else the provider does may need them.
- */
-export declare function collectProviderScriptsWithoutComponents(modules: Iterable<ComponentBearingProviderModule>, registrations: Iterable<ProviderComponentRegistration>): ReadonlyArray<DeclaredProviderScript>;
-export {};
 //# sourceMappingURL=provider-component-registry.frontend.service.d.ts.map

package/dist/esm/core/components-registry/provider-component-registry.frontend.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"provider-component-registry.frontend.service.d.ts","sourceRoot":"","sources":["../../../../../src/core/components-registry/provider-component-registry.frontend.service.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"provider-component-registry.frontend.service.d.ts","sourceRoot":"","sources":["../../../../src/core/components-registry/provider-component-registry.frontend.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EACV,mCAAmC,EACnC,yBAAyB,EAC1B,MAAM,0CAA0C,CAAC;AAGlD,0EAA0E;AAC1E,MAAM,MAAM,iBAAiB,GAAG,KAAK,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;AAE3D,oGAAoG;AACpG,MAAM,MAAM,4BAA4B,GAAG,yBAAyB,CAAC,iBAAiB,CAAC,CAAC;AAIxF;;;;;;;;;GASG;AACH,wBAAgB,kCAAkC,CAAC,OAAO,EAAE,QAAQ,CAAC,mCAAmC,CAAC,GAAG,IAAI,CAE/G;AAED,+FAA+F;AAC/F,wBAAgB,uCAAuC,IAAI,WAAW,CAAC,MAAM,EAAE,mCAAmC,CAAC,CAElH;AAED,mDAAmD;AACnD,wBAAgB,yCAAyC,IAAI,IAAI,CAEhE"}