react-semaphor 0.1.506 → 0.1.508

package/dist/types/shared/analytics-protocol/index.d.ts

@@ -16,6 +16,8 @@ export * from './fixtures.js';
 export * from './metric-comparison.js';
 export * from './dashboard-date-comparison-definition.js';
 export * from './dashboard-input-contract.js';
+export * from './selection-contract.js';
+export * from './selection-filter-compiler.js';
 export * from './temporal-context.js';
 export * from './temporal-bucket-contract.js';
 export * from './raw-temporal-contract.js';

package/dist/types/shared/analytics-protocol/selection-contract.d.ts

@@ -0,0 +1,100 @@
+import { z } from 'zod';
+import { SemaphorFieldRef, SemaphorSourceRef, TemporalBucketMetadata } from './contracts.js';
+/**
+ * A selection is what a viewer picked by clicking marks, rows, or members on
+ * one card. It is a dashboard input value: other cards narrow to it the same
+ * way they narrow to a toolbar filter. The protocol owns these shapes so the
+ * dashboard runtime, the Data App SDK, and the server share one contract.
+ */
+export type SelectionFieldSource = Extract<SemaphorSourceRef, {
+    kind: 'semantic' | 'physical';
+}>;
+/**
+ * A source-qualified field. Structurally identical to the persisted dashboard
+ * filter target field; declared here so the protocol does not depend on
+ * dashboard authoring.
+ */
+export type SelectionField = {
+    name: string;
+    source: SelectionFieldSource;
+    dataType: 'string' | 'number' | 'boolean' | 'date' | 'datetime';
+    /** Physical column when it differs from the semantic name. */
+    sourceField?: string;
+};
+/** One field condition from a click, grounded on the source card's own executable source. */
+export type SelectionCondition = {
+    field: SelectionField;
+    operator: '=' | 'isNull';
+    value: string | number | null;
+    /** Display only; never identity, never SQL. */
+    label?: string;
+    /** Present when the value is a canonical grouped-temporal scalar. */
+    temporalBucket?: TemporalBucketMetadata;
+};
+/** One selected item. Conditions are AND-ed. */
+export type SelectionTuple = {
+    conditions: SelectionCondition[];
+};
+/** Runtime value of a selection input. Tuples are OR-ed. */
+export type SelectionInputValue = {
+    kind: 'selection';
+    sourceCardId: string;
+    /** 1..SELECTION_LIMIT. An empty selection clears the slot instead of storing []. */
+    tuples: SelectionTuple[];
+};
+/** One source-owned analytical selection transported outside dashboard state. */
+export type AnalyticsSelectionCondition = {
+    field: SemaphorFieldRef;
+    operator: '=' | 'isNull';
+    value: string | number | null;
+    temporalBucket?: TemporalBucketMetadata;
+};
+export type AnalyticsSelectionTuple = {
+    conditions: AnalyticsSelectionCondition[];
+};
+export type AnalyticsSelection = {
+    id: string;
+    tuples: AnalyticsSelectionTuple[];
+};
+/** Enforced by the schema and by the selection reducer. */
+export declare const SELECTION_LIMIT = 100;
+/**
+ * Stable identity of a clicked field across sessions and saves. It is
+ * persisted in chosen columns and bound mappings, so the source part is the
+ * protocol's dataset identity. Connection and label changes never affect it;
+ * a display-name change is also stable when the semantic source has datasetId.
+ */
+export declare function selectionFieldKey(field: SelectionField): string;
+export declare function selectionInputId(sourceCardId: string): string;
+export declare function isSelectionInputId(inputId: string): boolean;
+export declare function sourceCardIdFromSelectionInputId(inputId: string): string | undefined;
+/**
+ * Identity of a temporal bucket's meaning. Every calendar member that changes
+ * which instants a bucket value covers is part of it: the same "Q1" under two
+ * fiscal calendars is two different selections.
+ */
+export declare function temporalBucketIdentityKey(bucket: TemporalBucketMetadata | undefined): string;
+/** Identity of one condition: field, operator, value and bucket meaning. Labels excluded. */
+export declare function selectionConditionKey(condition: SelectionCondition): string;
+/** Stable, order-insensitive identity of a tuple. Labels are display only and excluded. */
+export declare function selectionTupleKey(tuple: SelectionTuple): string;
+/** Stable, display-metadata-insensitive identity for a transported condition. */
+export declare function analyticsSelectionConditionKey(condition: AnalyticsSelectionCondition): string;
+/** Stable, order-insensitive identity for one transported tuple. */
+export declare function analyticsSelectionTupleKey(tuple: AnalyticsSelectionTuple): string;
+/**
+ * Canonical request snapshot. Selection, tuple, and condition order do not
+ * change query identity; labels and other display metadata remain untouched.
+ */
+export declare function canonicalizeAnalyticsSelections(selections: readonly AnalyticsSelection[]): AnalyticsSelection[];
+/** Order-insensitive over conditions; ignores labels. */
+export declare function sameSelectionTuple(a: SelectionTuple, b: SelectionTuple): boolean;
+/** "West · Enterprise". Uses the display label when the click supplied one. */
+export declare function selectionTupleLabel(tuple: SelectionTuple): string;
+export declare const selectionFieldSchema: z.ZodType<SelectionField>;
+export declare const selectionConditionSchema: z.ZodType<SelectionCondition>;
+export declare const selectionTupleSchema: z.ZodType<SelectionTuple>;
+export declare const selectionInputValueSchema: z.ZodType<SelectionInputValue>;
+export declare const analyticsSelectionConditionSchema: z.ZodType<AnalyticsSelectionCondition>;
+export declare const analyticsSelectionTupleSchema: z.ZodType<AnalyticsSelectionTuple>;
+export declare const analyticsSelectionSchema: z.ZodType<AnalyticsSelection>;

package/dist/types/shared/analytics-protocol/selection-filter-compiler.d.ts

@@ -0,0 +1,12 @@
+import { FilterCondition, FilterGroup } from '../../lib/types/explorer-types.js';
+/** One source selection already projected into executable filter conditions. */
+export type SelectionFilterSource = {
+    sourceCardId: string;
+    tuples: Array<{
+        conditions: FilterCondition[];
+    }>;
+};
+/** AND across sources, OR across tuples per source, AND within each tuple. */
+export declare function compileSelectionFilterGroup(sources: SelectionFilterSource[]): FilterGroup | undefined;
+/** Stable and order-insensitive across sources, tuples and conditions. */
+export declare function selectionFilterGroupKey(sources: SelectionFilterSource[]): string;

package/dist/types/shared/dashboard-authoring/apply-group-by-override.d.ts

@@ -0,0 +1,19 @@
+import { CardConfig, GroupByField } from '../../lib/types/explorer-types.js';
+/**
+ * What happens to a card's sorts when its grouping is replaced at runtime.
+ *
+ * - `dropUnrelatedSorts`: a field-selector control swaps the grouping for an
+ *   unrelated field, so only sorts on the new grouping or on a metric survive.
+ * - `retargetDimensionSort`: a drill walks down from the grouping, so a sort on
+ *   the old grouping follows the viewer to the new field and keeps its
+ *   direction. Every other sort is kept.
+ */
+export type GroupBySortPolicy = 'dropUnrelatedSorts' | 'retargetDimensionSort';
+/**
+ * Replaces a card's grouping with one field. The single transform behind the
+ * `config_field_selector` control binding and the drill path, so neither can
+ * produce an ORDER BY the other would not.
+ */
+export declare function applyGroupByOverride(cardConfig: CardConfig, groupByField: GroupByField, options: {
+    sortPolicy: GroupBySortPolicy;
+}): CardConfig;

package/dist/types/shared/dashboard-authoring/click-to-filter-settings.d.ts

@@ -0,0 +1,88 @@
+import { z } from 'zod';
+import { SelectionField } from '../analytics-protocol/selection-contract.js';
+import { DashboardInputScope, TCard } from '../../lib/types/common-types.js';
+import { Field } from '../../lib/types/explorer-types.js';
+import { buildDashboardCardSourceIndex, DashboardCardFilterSourceInventory } from './dashboard-card-source-index.js';
+import { DashboardFilterTarget } from './dashboard-filter-mapping-types.js';
+/** Which fields a click on this card carries. */
+export type ClickToFilterFieldsRule = 
+/** Table: every dimension column on the row. Matrix: the full path. Chart: every dimension of the clicked mark. */
+{
+    kind: 'wholeRow';
+}
+/** Table only: the dimension column that was clicked. */
+ | {
+    kind: 'clickedCell';
+}
+/** Stable keys from `selectionFieldKey`; explorer field ids are not stable. */
+ | {
+    kind: 'chosenColumns';
+    clickedFieldKeys: string[];
+};
+/** Matrix only: which parts of the grid start a selection. */
+export type ClickToFilterMatrixSources = {
+    rowMembers: boolean;
+    columnMembers: boolean;
+    cells: boolean;
+};
+/** Sparse per-target overrides. Automatic matches are never written. */
+export type ClickToFilterCardMapping = {
+    kind: 'bound';
+    /** Target card. */
+    cardId: string;
+    clickedFieldKey: string;
+    /** Same target shape toolbar filter mappings persist. */
+    target: DashboardFilterTarget;
+}
+/** "Not applied": this target never receives this source's clicks. */
+ | {
+    kind: 'excluded';
+    cardId: string;
+};
+export type ClickToFilterSettings = {
+    enabled: boolean;
+    fields: ClickToFilterFieldsRule;
+    /** Cmd/Ctrl toggle and Shift range allowed. */
+    multipleSelection: boolean;
+    /** 'auto' shows checkboxes on coarse pointers only. */
+    selectionCheckboxes: 'auto' | 'always' | 'never';
+    /** matrixTable only; absent means all three true. */
+    matrixSources?: ClickToFilterMatrixSources;
+    /** Which cards may receive clicks. */
+    targets: DashboardInputScope;
+    cardMappings: ClickToFilterCardMapping[];
+};
+/**
+ * Instance-level overrides for a linked library visual. `null` means cleared
+ * on this instance. The helpers that build and apply these arrive with the
+ * authoring phase; the persisted shape is declared here with the settings.
+ */
+export type LinkedClickToFilterOverrides = {
+    targets?: DashboardInputScope | null;
+    cardMappings?: ClickToFilterCardMapping[] | null;
+};
+export type ClickToFilterDashboardDefault = 'on' | 'off';
+export declare function defaultClickToFilterSettings(card: Pick<TCard, 'type'>, dashboardDefault: ClickToFilterDashboardDefault): ClickToFilterSettings;
+/**
+ * Grounds an explorer field on one of the card's own executable sources.
+ * A field that carries catalog identity must match an executable source. A
+ * field without it is grounded by its entity, or by the card's single source.
+ * Calculated fields and unknown data types cannot be grounded.
+ */
+export declare function selectionFieldFromExplorerField(field: Field, sourceIndex: DashboardCardFilterSourceInventory): SelectionField | undefined;
+/** The source-index members ground a legacy attribute trigger to a stable field key. */
+type NormalizableCard = Pick<TCard, 'type' | 'clickToFilter' | 'interactionConfig'> & Parameters<typeof buildDashboardCardSourceIndex>[0];
+/**
+ * Effective settings for a card. If `card.clickToFilter` is absent, derives
+ * them from legacy `interactionConfig.interactions` entries with mode
+ * 'clickFilter': trigger type 'attribute' becomes chosenColumns of that field,
+ * 'metric' (or no trigger) becomes wholeRow, `applyToCardIds` becomes card
+ * targets, and `excludeCardIds` become excluded mappings. A legacy entry means
+ * the author turned the behavior on, so the result is enabled regardless of
+ * the dashboard default. Pure; never writes.
+ */
+export declare function normalizeClickToFilterSettings(card: NormalizableCard, dashboardDefault: ClickToFilterDashboardDefault): ClickToFilterSettings;
+export declare const clickToFilterSettingsSchema: z.ZodType<ClickToFilterSettings>;
+export declare const respondsToSelectionsSchema: z.ZodBoolean;
+export declare const linkedClickToFilterOverridesSchema: z.ZodType<LinkedClickToFilterOverrides>;
+export {};

package/dist/types/shared/dashboard-authoring/contracts.d.ts

@@ -18,6 +18,10 @@ export type DashboardPlanCard = {
     section?: string;
     analyticsIntent?: SemaphorAnalyticsIntent;
     text?: string;
+    /** Canonical click-to-filter settings. Legacy interactionConfig payloads are not accepted. */
+    clickToFilter?: TCard['clickToFilter'];
+    /** Whether this card accepts selections from other cards. */
+    respondsToSelections?: TCard['respondsToSelections'];
 };
 export type DashboardPlanSheet = {
     id: string;
@@ -117,6 +121,10 @@ export type DashboardChangeOperation = {
     cardId: string;
     title: string;
     description?: string;
+} | {
+    kind: 'updateCardSelectionSettings';
+    cardId: string;
+    card: Pick<DashboardPlanCard, 'clickToFilter' | 'respondsToSelections'>;
 } | {
     kind: 'reorderCards';
     cardIds: string[];

package/dist/types/shared/dashboard-authoring/index.d.ts

@@ -17,6 +17,9 @@ export * from './dashboard-filter-sql-target.js';
 export * from './dashboard-filter-mapping-contract.js';
 export * from './dashboard-filter-value-compatibility.js';
 export * from './card-reference-remapping.js';
+export * from './apply-group-by-override.js';
+export * from './click-to-filter-settings.js';
+export * from './linked-click-to-filter-overrides.js';
 export * from './matrix-definition.js';
 export * from './matrix-authoring.js';
 export * from './field-aggregations.js';

package/dist/types/shared/dashboard-authoring/linked-click-to-filter-overrides.d.ts

@@ -0,0 +1,32 @@
+import { TCard } from '../../lib/types/common-types.js';
+import { ClickToFilterSettings, LinkedClickToFilterOverrides } from './click-to-filter-settings.js';
+type IdMapping = {
+    cardIds?: Record<string, string>;
+    sheetIds?: Record<string, string>;
+    sectionIds?: Record<string, string>;
+};
+/** Rewrites every card and sheet id the settings hold. The one walker for these references. */
+export declare function remapClickToFilterReferences(settings: ClickToFilterSettings, mapping: IdMapping): ClickToFilterSettings;
+/** The same rewrite for an instance's overrides; `undefined` and `null` pass through. */
+export declare function remapLinkedClickToFilterOverrides(overrides: LinkedClickToFilterOverrides, mapping: IdMapping): LinkedClickToFilterOverrides;
+/** `undefined` keeps the library value; `null` clears it on this instance. */
+export declare function applyLinkedClickToFilterOverrides(settings: ClickToFilterSettings, overrides: LinkedClickToFilterOverrides | undefined): ClickToFilterSettings;
+/**
+ * What this instance changed relative to the library settings, already
+ * remapped to the instance's ids. Undefined when nothing differs, so an
+ * instance that follows its library carries no override.
+ */
+export declare function buildLinkedClickToFilterOverrides(instanceSettings: ClickToFilterSettings, remappedLibrarySettings: ClickToFilterSettings): LinkedClickToFilterOverrides | undefined;
+/**
+ * The settings a library save may contain: the edited behavior, with the
+ * library's own targeting untouched. Instance targeting is saved as overrides.
+ */
+export declare function stripInstanceTargetsForLibrarySave(settings: ClickToFilterSettings, librarySettings: ClickToFilterSettings | undefined): ClickToFilterSettings;
+/**
+ * Reads the per-interaction overrides linked cards saved before click to
+ * filter became a card setting, with the legacy normalizer's semantics: the
+ * union of the inclusive lists is the target set, and a card is excluded only
+ * when every open entry excludes it.
+ */
+export declare function normalizeLegacyLinkedTargetOverrides(card: Pick<TCard, 'linkedInteractionTargetOverrides'>): LinkedClickToFilterOverrides | undefined;
+export {};

package/dist/types/shared/format-utils/matrix-continuation.d.ts

@@ -91,13 +91,13 @@ export declare const matrixBatchResponseSchema: z.ZodDiscriminatedUnion<"kind",
 }, "strip", z.ZodTypeAny, {
     kind: "committed";
     sequence: number;
-    deadlineAt: number;
     done: boolean;
+    deadlineAt: number;
 }, {
     kind: "committed";
     sequence: number;
-    deadlineAt: number;
     done: boolean;
+    deadlineAt: number;
 }>]>;
 /** Count the complete JSON envelope in UTF-8, including escaping and transport fields. */
 export declare function assertMatrixBatchResponseSize(value: unknown): void;
@@ -116,8 +116,8 @@ export declare function parseMatrixBatchResponse(value: unknown, input: MatrixBa
 } | {
     kind: "committed";
     sequence: number;
-    deadlineAt: number;
     done: boolean;
+    deadlineAt: number;
 };
 export declare const matrixManifestSchema: z.ZodEffects<z.ZodObject<{
     acquisition: z.ZodLiteral<"continuation">;

package/package.json

@@ -5,7 +5,7 @@
     "email": "support@semaphor.cloud"
   },
   "license": "MIT",
-  "version": "0.1.506",
+  "version": "0.1.508",
   "description": "Fully interactive and customizable dashboards for your apps.",
   "keywords": [
     "react",

package/src/data-app-sdk/README.md

@@ -13,6 +13,7 @@ import {
   semaphor,
   useClearInvalidSemaphorInputValue,
   useSemaphorInputs,
+  useSemaphorSelection,
   useSemaphorQuery,
 } from "react-semaphor/data-app-sdk";
 
@@ -118,7 +119,8 @@ Important state fields:
 - `isEmpty`: successful query returned no meaningful rows/options/cells/value.
 - `isPartial`: execution status, coverage, diagnostic feedback, or row-limit
   metadata says the result is incomplete.
-- `isFiltered`: one or more active filter inputs were applied to the query.
+- `isFiltered`: one or more active filter inputs or selections were applied to
+  the query.
 - `isStale`: previous successful data is being shown while newer inputs load.
 - `isValidated`: validation metadata is present.
 
@@ -184,6 +186,61 @@ const revenueBySegment = semaphor.records({
 const result = useSemaphorQuery(revenueBySegment);
 ```
 
+## Click Selection
+
+Create one selection input per source chart. Keep it separate from scalar filter
+and control inputs, pass its handle through the `selections` query option, and
+render its removable chips in the app.
+
+```tsx
+const segmentSelection = semaphor.selection({
+  id: "segment-chart-selection",
+  label: "Segment chart selection",
+  fields: [segment],
+});
+
+function SegmentDashboard() {
+  const selection = useSemaphorSelection(segmentSelection);
+  const chartResult = useSemaphorQuery(revenueBySegment);
+  const detailResult = useSemaphorQuery(revenueBySegment, {
+    selections: [selection],
+  });
+
+  const enterprise = {
+    conditions: [
+      { field: segment, operator: "=" as const, value: "Enterprise" },
+    ],
+  };
+
+  return (
+    <>
+      <SegmentChart result={chartResult} selection={selection} />
+      <button onClick={() => selection.select(enterprise, { kind: "toggle" })}>
+        Enterprise
+      </button>
+      {selection.tuples.map((tuple) => (
+        <button
+          key={JSON.stringify(tuple)}
+          onClick={() => selection.select(tuple, { kind: "toggle" })}
+        >
+          {tuple.conditions.map((condition) => String(condition.value)).join(" · ")} ×
+        </button>
+      ))}
+      <RecordsTable result={detailResult} />
+    </>
+  );
+}
+```
+
+The source chart query deliberately omits its own selection handle, so selected
+marks stay visible. Pass the handle to every query that should respond.
+
+A tuple combines its conditions with AND. Multiple tuples combine with OR, so
+`(region = West AND segment = Enterprise) OR (region = East AND segment = SMB)`
+stays grouped. The shared reducer caps a selection at 100 distinct tuples and
+returns `limitReached`; show that outcome beside the chips. Selection handles
+have no `toAnalyticsInput()` method and never belong in `inputs`.
+
 ## Row Access
 
 Read rows with `columns[].key`; display `columns[].label`.

package/dist/chunks/appearance-context-tNjvTJj3.cjs

@@ -1 +0,0 @@
-"use strict";const C=require("react"),g=require("./color-CyB5o13F.cjs"),d=require("./index-C8XCKzB6.cjs"),E={background:"--semaphor-background",foreground:"--semaphor-foreground",muted:"--semaphor-muted",mutedForeground:"--semaphor-muted-foreground",border:"--semaphor-border",input:"--semaphor-input",primary:"--semaphor-primary",primaryForeground:"--semaphor-primary-foreground",accent:"--semaphor-accent",accentForeground:"--semaphor-accent-foreground",card:"--semaphor-card",cardForeground:"--semaphor-card-foreground",positive:"--semaphor-positive",negative:"--semaphor-negative",warning:"--semaphor-warning",info:"--semaphor-info",destructive:"--semaphor-destructive",destructiveForeground:"--semaphor-destructive-foreground"},k={light:{"--semaphor-code-string":"158 64% 22%","--semaphor-code-number":"158 64% 22%","--semaphor-code-boolean":"158 64% 22%","--semaphor-code-fn":"217 91% 40%","--semaphor-code-keyword":"263 70% 42%"},dark:{"--semaphor-code-string":"158 64% 52%","--semaphor-code-number":"158 64% 52%","--semaphor-code-boolean":"158 64% 52%","--semaphor-code-fn":"213 94% 68%","--semaphor-code-keyword":"264 89% 74%"}};function _(e){var a,c,s,u,f,p,h,i;const o=e.defaults??d.SEMAPHOR_DEFAULT_APPEARANCE_SPEC,n=e.mode??x(e.spec.mode,e.systemMode),r=e.spec.schemes[n]??o.schemes[n],m=((a=r.tokens)==null?void 0:a.color)??{},t={...k[n]};for(const[l,R]of Object.entries(E)){const A=m[l];if(!A)continue;const F=g.compileColorToHslTriplet(A);if(!F)throw new Error(`Invalid compiled appearance color for ${l}`);t[R]=F}return T(t,(c=r.tokens)==null?void 0:c.radius),O(t,(s=r.tokens)==null?void 0:s.typography),{mode:n,scheme:r,cssVariables:t,colorValues:m,chartPalette:((f=(u=r.components)==null?void 0:u.chart)==null?void 0:f.palette)??((h=(p=o.schemes[n].components)==null?void 0:p.chart)==null?void 0:h.palette)??d.SEMAPHOR_DEFAULT_CHART_PALETTE,table:(i=r.components)==null?void 0:i.table}}function O(e,o){o!=null&&o.fontFamily&&(e["--semaphor-font-family"]=o.fontFamily),o!=null&&o.headingFontFamily&&(e["--semaphor-heading-font-family"]=o.headingFontFamily),o!=null&&o.monoFontFamily&&(e["--semaphor-mono-font-family"]=o.monoFontFamily),(o==null?void 0:o.baseFontSize)!==void 0&&(e["--semaphor-font-size"]=`${o.baseFontSize}px`)}function T(e,o){e["--semaphor-brand"]=e["--semaphor-primary"]??e["--semaphor-foreground"],e["--semaphor-secondary"]=e["--semaphor-accent"]??e["--semaphor-muted"],e["--semaphor-secondary-foreground"]=e["--semaphor-accent-foreground"]??e["--semaphor-foreground"],e["--semaphor-popover"]=e["--semaphor-card"]??e["--semaphor-background"],e["--semaphor-popover-foreground"]=e["--semaphor-card-foreground"]??e["--semaphor-foreground"],e["--semaphor-ring"]=e["--semaphor-primary"]??e["--semaphor-foreground"];const n=S((o==null?void 0:o.control)??5),r=S((o==null?void 0:o.card)??(o==null?void 0:o.control)??5);e["--semaphor-radius"]=n,e["--semaphor-control-radius"]=n,e["--semaphor-card-radius"]=r}function S(e){return`${Number((e/16).toFixed(4))}rem`}function x(e,o="light"){return e==="system"?o:e}const z=_({spec:d.resolveAppearance(),mode:"light"}),v=C.createContext(P("semaphor-default-appearance",z));function L(){return C.useContext(v)}function P(e,o){return{instanceId:e,compiledAppearance:o,scopeProps:M(e,o),portalSnapshot:{instanceId:e,compiledAppearance:o}}}function M(e,o){return{className:o.mode,style:w(o),"data-semaphor-theme":o.mode,"data-semaphor-appearance-instance":e}}function w(e){var t,a;const o={colorScheme:e.mode};e.cssVariables["--semaphor-font-family"]&&(o.fontFamily="var(--semaphor-font-family)");const r=(t=e.scheme.tokens)==null?void 0:t.typography,m=(a=d.SEMAPHOR_DEFAULT_APPEARANCE_SPEC.schemes[e.mode].tokens)==null?void 0:a.typography;(r==null?void 0:r.baseFontSize)!==void 0&&r.baseFontSize!==(m==null?void 0:m.baseFontSize)&&(o.fontSize=r.baseFontSize);for(const[c,s]of Object.entries(e.cssVariables))o[c]=s;return o}exports.APPEARANCE_COLOR_CSS_VARS=E;exports.AppearanceContext=v;exports.compileAppearance=_;exports.createAppearanceContextValue=P;exports.useAppearance=L;