@jini-ai/ui 0.6.16 → 0.6.19

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @jini-ai/ui
 
+## 0.6.19
+
+- A `<provider>.<kind>-chart` entry from `createChartInteractiveRegistry` now draws with the provider it advertises. Components were cached by chart kind only, so with another enabled provider as the site default, `plugin.echarts.bar-chart` could render through that default. The legacy `recharts.*` aliases and `chart.spec` keep generic selection.
+- `@jini-ai/ui/charts` adds `chartCatalogManifests({ providers }, { siteProvider })`, the one headless owner of chart catalog entries: per-provider `<provider>.<kind>-chart` entries (now described), the legacy `recharts.*` entries with unchanged ids, schemas and descriptions, and a stable `chart.spec` entry (`{ spec }`, any kind, one or more series; `chartSpecPropsSchema` rejects empty series or data, rows missing a series or category, and non-numeric series values). `chart.spec` is listed with zero providers and then renders the data table.
+- `createChartInteractiveRegistry` now attaches components to exactly those manifests. The unadvertised `core.table.<kind>-chart` fallback ids are gone; the legacy `recharts.*` ids report `core.table` when no provider draws their kind.
+- `DEFAULT_INTERACTIVE_UI_REGISTRY` now also holds `chart.spec` (after the legacy chart ids), so a host with no chart provider snapshot still renders a saved `chart.spec` surface as the data table. `ALL_MANIFESTS` is unchanged.
+
+## Unreleased (0.6.18)
+
+- Redact sketch export and rich-text editor callback exception diagnostics without Node-only imports.
+
+## 0.6.17
+
+### Patch Changes
+
+- Add localized folder-chip strings.
+- Handle npm 12 pack JSON through the shared parser in publication-hygiene tests.
+
 ## 0.6.16
 
 ### Minor Changes

package/dist/features/charts/catalog-manifests.d.ts

@@ -0,0 +1,25 @@
+import type { InteractiveComponentManifest } from '../interactive-ui/types.js';
+import { type ChartKind } from './contract.js';
+/** What a catalog needs to know about an admitted provider: no code, no URLs. */
+export interface ChartCatalogProvider {
+    readonly id: string;
+    readonly kinds: readonly ChartKind[];
+}
+/** Stable id for the generic multi-series entry. It exists with zero providers (it renders as a table). */
+export declare const CHART_SPEC_COMPONENT_ID = "chart.spec";
+/** Provider id the catalog reports when no admitted provider draws a kind. */
+export declare const CHART_TABLE_PROVIDER = "core.table";
+/**
+ * Build every chart entry for the current admitted providers:
+ * - one `<provider>.<kind>-chart` entry per provider and kind it draws, in selection order;
+ * - the legacy wire entries (unchanged ids, schemas and descriptions), reporting the selected provider;
+ * - `chart.spec`, present even with no provider.
+ * @complexity O(k * p) for k kinds and p providers.
+ * @example chartCatalogManifests({ providers: [{ id: 'plugin.charts', kinds: ['bar'] }] }, { siteProvider: 'plugin.charts' })
+ */
+export declare function chartCatalogManifests({ providers }: {
+    providers: readonly ChartCatalogProvider[];
+}, { siteProvider }?: {
+    siteProvider?: string | undefined;
+}): readonly InteractiveComponentManifest[];
+//# sourceMappingURL=catalog-manifests.d.ts.map

package/dist/features/charts/catalog-manifests.js

@@ -0,0 +1,73 @@
+/** The one headless owner of chart catalog entries. The browser registry attaches components to
+ * these exact entries; a server catalog serves them as they are. React-free and DOM-free.
+ */
+import { z } from 'zod';
+import { chartSpecSchema } from './contract.js';
+import { chartCapability, chartProvidersByKind, createChartProviderRegistry } from './registry.js';
+import { chartSpecPropsSchema, chartWireManifests } from './wire.js';
+/** Stable id for the generic multi-series entry. It exists with zero providers (it renders as a table). */
+export const CHART_SPEC_COMPONENT_ID = 'chart.spec';
+/** Provider id the catalog reports when no admitted provider draws a kind. */
+export const CHART_TABLE_PROVIDER = 'core.table';
+const LEGACY_KINDS = ['bar', 'line', 'pie'];
+/** Catalog selection only needs ids and kinds; provider code always loads in the browser. */
+function catalogProviderRegistry({ providers }, _options = {}) {
+    return createChartProviderRegistry({ providers: providers.map(({ id, kinds }) => ({
+            id, kinds, enabled: true, load: () => Promise.reject(new Error('Chart catalogs list providers; they never load them.')),
+        })) });
+}
+/** Legacy kinds keep their wire schema (shared by reference); other kinds take `{ spec }` of that kind. */
+function kindPropsSchema({ kind }, { wire } = {}) {
+    return wire?.propsSchema ?? z.object({ spec: chartSpecSchema.extend({ kind: z.literal(kind) }) }).passthrough();
+}
+function providerDescription({ kind, provider }, { wire } = {}) {
+    const props = wire ? `Same props as ${wire.id} (one series)` : `Props: { spec } with spec.kind "${kind}"`;
+    return `${kind} chart drawn by ${provider}. ${props}. For several series use ${CHART_SPEC_COMPONENT_ID}.`;
+}
+function specDescription({ kinds }, _options = {}) {
+    const drawn = kinds.length > 0
+        ? `Kinds the enabled chart providers draw: ${kinds.join(', ')}. Other kinds show the data as a table.`
+        : 'No chart provider is enabled, so the data shows as a table.';
+    return 'Any chart from one neutral spec, with one or more series: { spec: { kind, data: rows, categoryKey, '
+        + 'series: [{ key, label? }] } }. Every row carries the category and a number (or null) for every series key. '
+        + `Set spec.provider to prefer one provider. ${drawn}`;
+}
+/** The provider the generic entry reports: the site default when admitted, else the first admitted one. */
+function specProvider({ providers }, { siteProvider } = {}) {
+    return (providers.find(({ id }) => id === siteProvider) ?? providers[0])?.id ?? CHART_TABLE_PROVIDER;
+}
+/**
+ * Build every chart entry for the current admitted providers:
+ * - one `<provider>.<kind>-chart` entry per provider and kind it draws, in selection order;
+ * - the legacy wire entries (unchanged ids, schemas and descriptions), reporting the selected provider;
+ * - `chart.spec`, present even with no provider.
+ * @complexity O(k * p) for k kinds and p providers.
+ * @example chartCatalogManifests({ providers: [{ id: 'plugin.charts', kinds: ['bar'] }] }, { siteProvider: 'plugin.charts' })
+ */
+export function chartCatalogManifests({ providers }, { siteProvider } = {}) {
+    const registry = catalogProviderRegistry({ providers });
+    const admitted = registry.list();
+    const kinds = [...new Set([...LEGACY_KINDS, ...admitted.flatMap(({ kinds }) => kinds)])];
+    const manifests = [];
+    for (const kind of kinds) {
+        const capability = chartCapability({ kind });
+        const wire = chartWireManifests.find((manifest) => manifest.capabilities.includes(capability));
+        const propsSchema = kindPropsSchema({ kind }, { wire });
+        const selected = chartProvidersByKind({ registry, kind }, { siteProvider });
+        // A provider literally named like a legacy prefix would mint the wire id twice; the wire entry wins.
+        for (const { id } of selected.filter((provider) => `${provider.id}.${capability}` !== wire?.id))
+            manifests.push({
+                id: `${id}.${capability}`, provider: id, capabilities: ['chart', capability, 'graph'], propsSchema,
+                description: providerDescription({ kind, provider: id }, { wire }),
+            });
+        if (wire)
+            manifests.push({ ...wire, provider: selected[0]?.id ?? CHART_TABLE_PROVIDER });
+    }
+    manifests.push({
+        id: CHART_SPEC_COMPONENT_ID, provider: specProvider({ providers: admitted }, { siteProvider }),
+        capabilities: ['chart', 'chart-spec'], propsSchema: chartSpecPropsSchema,
+        description: specDescription({ kinds: [...new Set(admitted.flatMap(({ kinds }) => kinds))] }),
+    });
+    return manifests;
+}
+//# sourceMappingURL=catalog-manifests.js.map

package/dist/features/charts/index.d.ts

@@ -1,4 +1,5 @@
-/** Headless chart contracts, schemas, theme tokens and registry selection (no React or DOM effects). */
+/** Headless chart contracts, schemas, theme tokens, registry selection and catalog manifests (no React or DOM effects). */
+export * from './catalog-manifests.js';
 export * from './contract.js';
 export * from './registry.js';
 export * from './wire.js';

package/dist/features/charts/index.js

@@ -1,4 +1,5 @@
-/** Headless chart contracts, schemas, theme tokens and registry selection (no React or DOM effects). */
+/** Headless chart contracts, schemas, theme tokens, registry selection and catalog manifests (no React or DOM effects). */
+export * from './catalog-manifests.js';
 export * from './contract.js';
 export * from './registry.js';
 export * from './wire.js';

package/dist/features/charts/react.d.ts

@@ -13,15 +13,19 @@ export interface ChartHostProps {
 }
 /** React owns only the container; mountChart owns its descendants and lifecycle. */
 export declare function ChartHost({ spec, registry, theme, siteProvider, onProviderError }: ChartHostProps): ReactElement;
-/** Create a snapshot for validation AND rendering. Resolve each legacy alias through its specific
- * capability, then copy its wire id onto that same entry (same schema and Component).
+type ChartHostOptions = {
+    siteProvider?: string | undefined;
+    theme?: ChartTheme;
+};
+/** Create a snapshot for validation AND rendering. The entries are exactly the headless catalog
+ * manifests (same ids, schemas and providers), each with a component; components are shared per
+ * (legacy kind, explicit provider), so a provider entry never draws with another provider.
+ * This closure is built once per host snapshot.
  * @example createChartInteractiveRegistry({ registry: base, providers }, { siteProvider: 'plugin.recharts' })
  */
 export declare function createChartInteractiveRegistry({ registry, providers }: {
     registry: InteractiveUiRegistry;
     providers: ChartProviderRegistry;
-}, options?: {
-    siteProvider?: string | undefined;
-    theme?: ChartTheme;
-}): InteractiveUiRegistry;
+}, options?: ChartHostOptions): InteractiveUiRegistry;
+export {};
 //# sourceMappingURL=react.d.ts.map

package/dist/features/charts/react.js

@@ -1,12 +1,12 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 /** The only React adapter for the vanilla chart lifecycle; providers own any internal roots. */
 import { useEffect, useRef } from 'react';
-import { z } from 'zod';
 import { InteractiveUiRegistry } from '../interactive-ui/registry.js';
 import { chartSpecSchema, DEFAULT_CHART_THEME } from './contract.js';
 import { mountChart } from './browser.js';
-import { chartCapability, chartProvidersByKind } from './registry.js';
-import { chartWireManifests, legacyChartSpec, withSeriesLabels } from './wire.js';
+import { CHART_SPEC_COMPONENT_ID, chartCatalogManifests } from './catalog-manifests.js';
+import { chartCapability } from './registry.js';
+import { chartSpecPropsSchema, chartWireManifests, legacyChartSpec, withSeriesLabels } from './wire.js';
 /** React owns only the container; mountChart owns its descendants and lifecycle. */
 export function ChartHost({ spec, registry, theme = DEFAULT_CHART_THEME, siteProvider, onProviderError }) {
     const element = useRef(null);
@@ -31,45 +31,52 @@ export function ChartHost({ spec, registry, theme = DEFAULT_CHART_THEME, sitePro
     }, [spec, theme]);
     return _jsx("div", { ref: element, className: "jini-chart-host" });
 }
-/** Known wire kinds use the established shapes. Other providers register spec-based entries without
- * adding fields or kinds to the core grammar. This closure is built once per host snapshot.
- */
 /** Wire kinds that predate spec-based entries and keep their established prop shapes. */
 const LEGACY_CHART_KINDS = ['bar', 'line', 'pie'];
-function chartComponent(kind, providers, options) {
+/** Known wire kinds use the established shapes. Every other entry, `chart.spec` included, takes
+ * `{ spec }`, so providers add kinds without adding fields or kinds to the core grammar.
+ * A `<provider>.<kind>-chart` entry passes its `provider`, so it draws with the provider it
+ * advertises rather than the site default; wire aliases and `chart.spec` keep generic selection.
+ */
+function chartComponent({ legacyKind, providers, provider }, options) {
     return function RegisteredChart(props) {
-        const legacyKind = LEGACY_CHART_KINDS.find((legacy) => legacy === kind);
-        const spec = withSeriesLabels({ spec: legacyKind ? legacyChartSpec({ kind: legacyKind, props }) : chartSpecSchema.parse(props.spec) });
+        // chart.spec has stricter row/series rules; provider-only kinds retain their own contract.
+        const parsed = legacyKind ? legacyChartSpec({ kind: legacyKind, props })
+            : provider ? chartSpecSchema.parse(props.spec) : chartSpecPropsSchema.parse(props).spec;
+        const spec = withSeriesLabels({ spec: provider ? { ...parsed, provider } : parsed });
         return _jsx(ChartHost, { spec: spec, registry: providers, ...options });
     };
 }
-/** Create a snapshot for validation AND rendering. Resolve each legacy alias through its specific
- * capability, then copy its wire id onto that same entry (same schema and Component).
+/** The provider a provider-specific entry draws with; undefined for wire aliases and `chart.spec`. */
+function explicitProviderOf({ manifest }, _options = {}) {
+    const generic = manifest.id === CHART_SPEC_COMPONENT_ID || chartWireManifests.some(({ id }) => id === manifest.id);
+    return generic ? undefined : manifest.provider;
+}
+/** The legacy kind an entry draws, read from its specific `<kind>-chart` capability. */
+function legacyKindOf({ manifest }, _options = {}) {
+    const capability = manifest.capabilities.find((candidate) => candidate.endsWith('-chart'));
+    return LEGACY_CHART_KINDS.find((kind) => chartCapability({ kind }) === capability);
+}
+/** Create a snapshot for validation AND rendering. The entries are exactly the headless catalog
+ * manifests (same ids, schemas and providers), each with a component; components are shared per
+ * (legacy kind, explicit provider), so a provider entry never draws with another provider.
+ * This closure is built once per host snapshot.
  * @example createChartInteractiveRegistry({ registry: base, providers }, { siteProvider: 'plugin.recharts' })
  */
 export function createChartInteractiveRegistry({ registry, providers }, options = {}) {
-    const kinds = [...new Set(['bar', 'line', 'pie', ...providers.list().flatMap(({ kinds }) => kinds)])];
-    const entries = [];
-    for (const kind of kinds) {
-        const capability = chartCapability({ kind });
-        const wire = chartWireManifests.find((manifest) => manifest.capabilities.includes(capability));
-        const Component = chartComponent(kind, providers, options);
-        const propsSchema = wire?.propsSchema ?? z.object({ spec: chartSpecSchema.extend({ kind: z.literal(kind) }) }).passthrough();
-        const selected = chartProvidersByKind({ registry: providers, kind }, options);
-        for (const provider of selected)
-            entries.push({
-                id: `${provider.id}.${capability}`, provider: provider.id, capabilities: ['chart', capability, 'graph'], propsSchema, Component,
-            });
-        if (wire)
-            entries.push({ ...wire, id: `core.table.${capability}`, Component });
-    }
+    const admitted = providers.list().filter(({ enabled }) => enabled).map(({ id, kinds }) => ({ id, kinds }));
+    const manifests = chartCatalogManifests({ providers: admitted }, { siteProvider: options.siteProvider });
+    const components = new Map();
+    const componentFor = (manifest) => {
+        const legacyKind = legacyKindOf({ manifest });
+        const provider = explicitProviderOf({ manifest });
+        const key = JSON.stringify([legacyKind ?? null, provider ?? null]);
+        const component = components.get(key) ?? chartComponent({ legacyKind, providers, provider }, options);
+        components.set(key, component);
+        return component;
+    };
+    const entries = manifests.map((manifest) => ({ ...manifest, Component: componentFor(manifest) }));
     const existing = registry.list().filter(({ capabilities }) => !capabilities.includes('chart'));
-    let snapshot = new InteractiveUiRegistry({ entries: [...entries, ...existing] });
-    for (const wire of chartWireManifests) {
-        const capability = wire.capabilities.find((capability) => capability.endsWith('-chart'));
-        const selected = snapshot.resolveByCapability({ capability })[0];
-        snapshot = snapshot.register({ entry: { ...selected, id: wire.id } });
-    }
-    return snapshot;
+    return new InteractiveUiRegistry({ entries: [...entries, ...existing] });
 }
 //# sourceMappingURL=react.js.map