@object-ui/components 17.6.0 → 17.7.0

package/dist/renderers/action/visibility-gate.d.ts

@@ -34,9 +34,13 @@
  *     scope (objectui#3848).
  *
  * The ruling: a gate is declared when normalization still leaves a condition to
- * evaluate. `''`, a whitespace-only string, an empty-`source` envelope and any
- * non-predicate value are therefore NOT declared, and one definition in core
- * says so for the renderers, `SchemaRenderer` and the execution entry alike.
+ * evaluate. `''`, a whitespace-only string and an empty-`source` envelope are
+ * therefore NOT declared, and one definition in core says so for the
+ * renderers, `SchemaRenderer` and the execution entry alike. (A non-predicate
+ * value — `0`, `{}`, an array, an `ast`-only envelope — was in that list until
+ * objectui#11358, which made it a DECLARED gate that cannot be evaluated: the
+ * normalizer keeps it, the evaluator faults on it, and each leg fails it in
+ * its key's fault direction — `visible` hidden, `disabled` greyed out.)
  *
  * The NAME is kept (`hasDeclaredVisibilityGate`) and this module keeps
  * re-exporting it: the five member-action call sites — `action:button`,
@@ -68,6 +72,10 @@
  *   | `{ source: '' }`             | shown → shown     | GREY → on         | on → on           |
  *   | `'   '` (whitespace)         | HIDDEN → shown    | on → on           | GREY → on         |
  *   | `0` / `{}` (not a predicate) | shown → shown     | GREY → on         | on → on           |
+ *
+ * (The table is objectui#3850's measurement. Since objectui#11358 the `0` /
+ * `{}` row reads HIDDEN / GREY / on: declared and faulting, each leg's fault
+ * direction — pinned in `__tests__/action-empty-predicate-scope.test.tsx`.)
  *   | `true` / `false` / CEL / `${…}`| unchanged        | unchanged         | unchanged         |
  *
  * The whitespace row is the one that moves on `visible`, and it moves toward the

package/dist/renderers/basic/elements.d.ts

@@ -22,5 +22,8 @@
  * All props are read off `schema.properties` per the spec's
  * `UIComponent.properties` convention; `schema.props` is also accepted
  * as a fallback so authors transitioning between conventions keep working.
+ * `element:number` also reads the node-level `dataSource` binding: its
+ * `object` wins over the flat one, and its filter is AND-combined with the
+ * flat one (objectui#10909).
  */
 export {};

package/dist/renderers/basic/html-elements.d.ts

@@ -11,9 +11,13 @@
  * PARSED (never executed) into the SDUI tree. For that tier to live up to its
  * name, the everyday HTML tags an author reaches for — headings, paragraphs,
  * lists, links, images, emphasis — must each resolve to a renderer (otherwise
- * the parser flags them `unknown-component`). div / span / table / code / label
- * and the semantic sectioning tags are registered elsewhere; this module fills
- * in the rest of the safe flow/inline set.
+ * the parser flags them `unknown-component`). div / span / table / label and
+ * the semantic sectioning tags are registered elsewhere; this module fills in
+ * the rest of the safe flow/inline set — `code` included (objectui#10756): the
+ * bare `code` key used to be the `field:code` widget's namespace fallback, so
+ * `<code>inline</code>` on an html page drew a code EDITOR and dropped its
+ * text. The widget now stands down from the bare key (`FIELD_TYPES_SKIP_FALLBACK`
+ * in `@object-ui/fields`) and stays reachable as `field:code`.
  *
  * Safety: these render real DOM, but the html tier never executes JS, so props
  * are static literals from the parser. As defense-in-depth the passthrough

package/dist/renderers/basic/readProps.d.ts

@@ -0,0 +1,60 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * The config bag an `element:*` renderer reads — THE one definition of it in
+ * `@object-ui/components` (objectui#6783).
+ *
+ * Per spec, element components carry their config in `schema.properties`;
+ * `schema.props` is tolerated as the legacy alias so JSON written either way
+ * works. `properties` wins a contested key — the 2026-08-18 cross-channel
+ * ruling (objectui#5123), whose spread order is preserved here verbatim and
+ * pinned by `packages/components/src/__tests__/alias-precedence-cross-channel.test.tsx`.
+ *
+ * ## The third channel (objectui#6783)
+ *
+ * This body used to be copied into five renderer modules — `elements.tsx`,
+ * `data-list.tsx`, `text-input.tsx`, `record-picker.tsx`,
+ * `metadata-viewer.tsx` — each spelling the two halves as
+ * `(schema?.properties ?? {}) as T`. `??` only replaces `null`/`undefined`, so
+ * a DEGENERATE bag (a string, a number, an array) went straight into the
+ * object spread and was re-read as its own indexed keys: for
+ * `properties: 'not-a-bag'` the bag a renderer received was
+ * `{ '0': 'n', '1': 'o', … '8': 'g' }` — nine keys nobody authored.
+ *
+ * That is the same hazard objectui#6752 and objectui#6760 closed in
+ * `packages/react/src/SchemaRenderer.tsx` on the two channels UPSTREAM of this
+ * one (the `props` evaluation memo plus `propsWithoutCanonicalKeys`, and the
+ * `properties` hoist). Those guards do not reach here, and are not meant to:
+ * what they buy is that the AUTHORED value's shape survives into the node, so
+ * a renderer downstream still receives `schema.properties === 'not-a-bag'` and
+ * gets to answer the question for itself. The three channels are in SERIES.
+ *
+ * ## Why it asks `isConfigBag` rather than carrying its own predicate
+ *
+ * Because a copy that DRIFTS produces no error — each spelling is a boolean
+ * expression, so two channels answering "is this a real config bag?"
+ * differently is silent by construction. objectui#6761 ended that inside
+ * `@object-ui/react` by converging six occurrences behind one exported
+ * definition and pinning it (`utils/configBag.pin.test.ts` fails on a seventh
+ * spelling); `@object-ui/components` depends on `@object-ui/react` — every one
+ * of the five modules above already imports from it — so the reachable answer
+ * here is to READ that definition, not to write the seventh spelling one
+ * package over where its pin cannot see it.
+ *
+ * ## What the guard buys, measured
+ *
+ * Not a rendered pixel, on today's tree: all five renderers read NAMED keys
+ * off this bag, and the one onward spread (`metadata-viewer`'s
+ * `<StateMachineView {...props} />`) hands them to components that destructure
+ * named fields, so the indexed keys were computed and then discarded. What it
+ * buys is the same thing objectui#6752 measured its own guard buys — the
+ * authored value's shape is not reinterpreted — one channel further down,
+ * which is exactly the property that stops mattering only until the first of
+ * these five spreads its bag onto a DOM element.
+ */
+export declare function readProps<T extends Record<string, any>>(schema: any): T;

package/dist/renderers/complex/data-table.d.ts

@@ -40,26 +40,43 @@ type BuiltinRowPredicates = NonNullable<DataTableSchema['rowEditPredicates'] | D
 export declare function isBuiltinRowActionVisible(predicates: Pick<BuiltinRowPredicates, 'visibleWhen'> | undefined, name: 'edit' | 'delete', row: any, scope: Record<string, unknown>): boolean;
 /**
  * Does this schema-driven custom row action render for THIS row? Same
- * single-definition rule as the built-ins above.
+ * single-definition rule as the built-ins above, and the ONE definition for
+ * every row menu: this file's (the related list's data table) and
+ * plugin-grid's `RowActionMenu` (its "⋮" items, its inline primary buttons and
+ * its "⋮" guard), which imports it from the `@object-ui/components` barrel
+ * rather than keeping a twin (objectui#11294).
  *
- * A gate counts as DECLARED by `!= null && !== ''`, never by truthiness
- * (objectui#3758). Truthiness cannot answer the question: `visible: false` is a
- * declared gate that excludes every row, and testing `!action.visible`
- * classified it as *ungated* — so the most explicit way to say "never show this"
- * rendered the item for everyone, and counted toward the "⋮" guard. This is the
- * invariant objectui#3492 established for the selection bar (plugin-grid's
- * `hasVisibilityGate`), and the same `!= null` posture the built-in `visibleWhen`
- * gate above has always had. The boolean then decides in
- * {@link evalRowActionVisibility}, which short-circuits it instead of handing it
- * to the engine.
+ * Whether a gate is DECLARED at all is asked with `hasDeclaredVisibilityGate`,
+ * the action family's one definition (objectui#3812): the related list's
+ * toolbar, `action:*`, `DeclaredActionsBar` and the rest ask it too, so an
+ * action cannot show in a list's header and be missing from its rows.
  *
- * `''` is grouped with `null` deliberately: an empty predicate is nothing to
- * evaluate, so it must not hide the item from everyone either.
+ * - `visible: false` is a declared gate that excludes every row. Truthiness
+ *   cannot answer the question: testing `!action.visible` read it as ungated
+ *   and rendered the item for everyone (objectui#3758). The boolean then
+ *   decides in {@link evalRowActionVisibility}, which short-circuits it instead
+ *   of handing it to the engine.
+ * - A blank predicate is no gate, so the action shows: `''`, a whitespace-only
+ *   string, and an envelope whose `source` is blank. The blank is still
+ *   reported (ADR-0137 D4) through the family's one `[blank]` report, once per
+ *   blank spelling rather than once per row. This test used to be
+ *   `pred == null || pred === ''`, so a whitespace-only `visible` counted as
+ *   declared, was evaluated, and failed closed: the action showed in a related
+ *   list's toolbar and was missing from its rows (objectui#11294).
+ * - A value that is not a predicate at all (`0`, `{}`, an array, an
+ *   `ast`-only envelope) IS a declared gate, one that cannot be evaluated
+ *   (objectui#11358): the family's definition answers "declared", the row fold
+ *   faults on it and fails closed, so the action is hidden and the fault is
+ *   reported — as on every other member of the family.
+ *
+ * `fields` is the object's field definitions, for a caller that has them:
+ * plugin-grid passes them so a relation compares as its stored foreign key
+ * (see `evalRowPredicate`). This file's own callers pass none.
  */
 export declare function isCustomRowActionVisible(action: {
     name?: string;
     visible?: unknown;
-} | undefined, row: any, scope: Record<string, unknown>): boolean;
+} | undefined, row: any, scope: Record<string, unknown>, fields?: unknown): boolean;
 /** What the row overflow menu will actually render for ONE row. */
 export interface DataTableRowMenuPlan {
     /** The built-in Edit item renders for this row. */

package/dist/renderers/complex/dataTableBindDiagnostic.d.ts

@@ -0,0 +1,187 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * The diagnostics that say out loud what `data-table` has always done silently
+ * with a key the AUTHOR wrote.
+ *
+ * TWO questions, one channel. The file is named for the first because it came
+ * first (objectui#6575); it was never limited to it.
+ *
+ *   1. `bind` was authored — and `data-table` does not read `bind` at all
+ *      (objectui#6575, maintainer ruling 2026-08-27, option A: 「同意」).
+ *   2. `data` was authored and is NOT an array — so the renderer dropped it to
+ *      zero rows at `data-table.tsx`'s
+ *      `Array.isArray(rawData) ? rawData : EMPTY_ROWS` (objectui#6665).
+ *
+ * They are deliberately two predicates asking two questions, not one widened
+ * predicate. The nodes that trip #2 carry no `bind` AT ALL, so #6575 staying
+ * silent on them is correct behaviour rather than a gap — the triage ruling on
+ * objectui#6665 is explicit about that, and widening #6575's question would
+ * have made its silence look like the defect. See {@link describeNonArrayData}.
+ *
+ * ## The first defect this names
+ *
+ * `bind` is the data-scope binding vocabulary: a path string resolved by
+ * `useDataScope()`. `list`, `tree-view` and the `object-*` plugin widgets read
+ * it. `DataTableRenderer` does NOT — it takes its rows from `data: rawData =
+ * EMPTY_ROWS` off the node, and the file calls no such hook.
+ *
+ * A `bind` on a `data-table` is nevertheless accepted by every gate: the TS
+ * side by `BaseSchema`'s `[key: string]: any`, the zod side by `BaseSchema`
+ * being `.passthrough()` (which `DataTableSchema.extend(…)` inherits). So the
+ * author gets a table drawing a correct-looking header over the "No results
+ * found" empty state, with no error, no warning and no diagnostic — the
+ * hardest failure shape for a human OR an AI author to self-check, because a
+ * rendered header reads as a success receipt.
+ *
+ * The platform was already paying a teaching cost for it rather than a
+ * diagnostic cost: `skills/objectui/rules/protocol.md` documents the pothole
+ * verbatim, and `skill-guide-data-table-binding.test.tsx` pins the behaviour.
+ * This module moves the warning from the docs to the console, where the author
+ * who did not read the docs is standing.
+ *
+ * ## What it deliberately does NOT do
+ *
+ * It changes NO behaviour. `data-table` still does not read `bind`, and the
+ * ruling is explicit that it must not start: making it a `useDataScope` reader
+ * (option B) is a separate published-surface question needing its own ruling.
+ * Refusing the key at parse (option C) stays blocked on the `.passthrough()`
+ * ceiling (objectui#5155 / objectui#6269). So the trap stops being silent; it
+ * does not stop being a trap.
+ *
+ * ⭐ The `data`-vs-`bind` PRECEDENCE half of that open question DISSOLVED at
+ * objectui#9308 rather than being answered. While `useDataScope` walked the
+ * injected adapter, `bind` and the node's own `data` were two spellings of one
+ * idea — "where this table's rows come from" — and a reader of both would have
+ * needed a rule. Since that ruling `bind` resolves a path in the ambient
+ * predicate scope and `data` is an inline array on the node: different
+ * channels, different questions, no precedence to decide. objectui#6575's
+ * ruling that `data-table` must not read `bind` is untouched by that, and this
+ * diagnostic's job is unchanged.
+ *
+ * ## Why a console warning, and only a console warning
+ *
+ * The same channel `plugin-grid`'s `columnSpellingDiagnostics.ts` uses for the
+ * identical shape of failure ("you declared something and the renderer dropped
+ * it"): a pure `describe…` function returning `string | null`, called from a
+ * `useEffect` keyed on the schema slice, one `console.warn`, no NODE_ENV
+ * branch. Deliberately the SAME shape rather than a second, differently-shaped
+ * one next to it. Rendering an in-table message instead would be user-facing
+ * copy needing all ten locale packs in `@object-ui/i18n`; a throw would take
+ * the surrounding page down for a defect that costs one table.
+ *
+ * The rate limit is the `useEffect` key, and that is enough HERE for a reason
+ * `visibilityDiagnostic.ts` does not have available: a node gate is evaluated
+ * once per row, so it needs a module-level dedupe `Set` to keep one authoring
+ * bug from printing N lines. A `data-table` is one node rendered once — the
+ * effect key is one line per mount per distinct `bind`, which is already the
+ * "one line per distinct authoring bug" ceiling that `Set` exists to buy.
+ *
+ * ## The message never asserts something it did not check
+ *
+ * A node can carry BOTH an inline `data` array and a `bind`. That table is not
+ * empty, so the "header over an empty body" consequence would be false there —
+ * and a diagnostic that overstates its own consequence teaches authors to
+ * distrust it. The two cases get two different consequence clauses, decided by
+ * looking at the rows the renderer actually resolved.
+ */
+/** Prefix for every `bind` line — the handle tests and greps hold. */
+export declare const DATA_TABLE_BIND_DIAGNOSTIC_PREFIX = "[ObjectUI] DataTable bind:";
+/** The key `data-table` really reads its rows from. */
+export declare const DECLARED_ROWS_KEY = "data";
+/** Where the offending node lives, for the first line of either message. */
+export interface DataTableNodeAddress {
+    /** The schema node's `type` — `data-table`, or an alias that routes here. */
+    blockType?: unknown;
+    /** The node's `id`, when it has one. */
+    id?: unknown;
+    /** The table's authored caption — often the only human-readable name. */
+    caption?: unknown;
+}
+/**
+ * Was a `bind` authored on this node?
+ *
+ * `undefined` is absence — a destructuring default or an omitted key. Every
+ * other value, including `null` and the empty string, is something the author
+ * WROTE, and writing it bought nothing. Exported so the renderer's effect key
+ * and this judgement cannot drift apart: one predicate, two readers.
+ */
+export declare function hasAuthoredBind(bind: unknown): boolean;
+/**
+ * The message for a `data-table` node carrying a `bind`, or `null` when there
+ * is nothing to say.
+ *
+ * `rows` is what the renderer resolved for the body — passed in rather than
+ * re-derived, so the consequence sentence is measured against the same array
+ * the reader is looking at.
+ *
+ * Naming the ADDRESS is the point: which node, which path it spells, what the
+ * renderer did instead, and what to write to get the rows on screen. A message
+ * that only said something went wrong would leave the author where the silence
+ * did.
+ */
+export declare function describeIgnoredBind(bind: unknown, rows: unknown, address: DataTableNodeAddress): string | null;
+/** Prefix for every non-array `data` line — the handle tests and greps hold. */
+export declare const DATA_TABLE_DATA_DIAGNOSTIC_PREFIX = "[ObjectUI] DataTable data:";
+/**
+ * Was `data` authored as something that is not an array?
+ *
+ * `undefined` is absence — an omitted key, or the renderer's destructuring
+ * default. Everything else the author WROTE, and `data-table.tsx` reduces every
+ * non-array value of it to `EMPTY_ROWS` without a word.
+ *
+ * ## Why this is not {@link hasAuthoredBind}'s question
+ *
+ * That one asks "was a `bind` authored?" — a key `data-table` does not read at
+ * all. This asks about `data`, the key it genuinely does read, and asks a
+ * SHAPE question about it rather than a presence one. The nodes that trip this
+ * carry no `bind`, so #6575's predicate is correctly silent on them; that
+ * silence is precisely why a second question had to be asked here instead of
+ * the first one being widened.
+ *
+ * ## Why the predicate is not keyed on the `${...}` shape
+ *
+ * The expression string is the spelling that was REPORTED, but it is not the
+ * defect. `Array.isArray(rawData) ? rawData : EMPTY_ROWS` swallows a number, an
+ * object, a `null` and a plain string exactly as silently, so a predicate that
+ * only caught `${...}` would leave the next non-array spelling to arrive as a
+ * fresh card. The shape only chooses the wording (see {@link TEMPLATE_SHAPE}).
+ *
+ * Exported so the renderer and this judgement cannot drift apart: one
+ * predicate, two readers.
+ */
+export declare function hasNonArrayAuthoredData(rawData: unknown): boolean;
+/**
+ * The message for a `data-table` node whose `data` is not an array, or `null`
+ * when there is nothing to say.
+ *
+ * ## Why no measured-consequence clause, unlike {@link describeIgnoredBind}
+ *
+ * That one has to look at the rows the renderer resolved, because a node can
+ * carry BOTH a `bind` and a real inline `data` array — "header over an empty
+ * body" would be false there. Here it cannot be: `data` is the ONLY row source
+ * `data-table` has, and this function is called exactly when that source is not
+ * an array, so the body is `EMPTY_ROWS` by construction. The consequence is
+ * stated because the predicate already established it, not asserted on faith.
+ *
+ * ## What it deliberately does NOT say
+ *
+ * It does not tell the author to move the expression under `properties`. The
+ * same expression IS evaluated there — that contrast is what makes this a
+ * defect rather than a design — but whether `properties` is an authoring
+ * channel for the `ui:*` / `page:*` namespaces is an open contract question,
+ * recorded in `skills/objectui/rules/protocol.md` rather than recommended by
+ * it. A console line is the wrong place to settle that, so the message teaches
+ * the one route the guides do teach: the host resolves the rows.
+ *
+ * It also changes NO behaviour. Making node-level `data` evaluate expressions
+ * is a behaviour change on a published component; the objectui#6665 triage
+ * ruling put that arm on the maintainer floor and dispatched only this one.
+ * The trap stops being silent; it does not stop being a trap.
+ */
+export declare function describeNonArrayData(rawData: unknown, address: DataTableNodeAddress): string | null;

package/dist/renderers/layout/box.d.ts

@@ -0,0 +1,8 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export {};

package/dist/renderers/layout/containers.d.ts

@@ -17,13 +17,4 @@
  *   - PageContainerProps -> page:footer / page:sidebar / page:section
  *                           (the thin wrappers; one shared `children` slot)
  */
-/**
- * Strip dangling connectors that survive when a `titleFormat` interpolates
- * with one side empty — e.g. `{number} - {name}` becomes `CTR-0001 -` when
- * `name` is blank. Removes a trailing/leading hyphen / middle-dot / colon /
- * slash / pipe (optionally surrounded by whitespace) and collapses
- * adjacent whitespace into a single space. Idempotent.
- *
- * Exported for unit tests.
- */
-export declare function cleanupTitleSeparators(s: string): string;
+export {};

package/dist/renderers/layout/react-page.d.ts

@@ -25,6 +25,10 @@
  *     expressed in HTML are injected.
  *   - `Block`                — escape hatch: `<Block type="object-grid" .../>`.
  *   - `useAdapter`            — live data hook: query/create/update objects.
+ *   - `useDataInvalidation`   — the data-invalidation bus reader: a nonce that
+ *     moves when a write to the named object is reported on the bus. A page
+ *     names it in the effect that reads through `useAdapter`, so that read
+ *     re-runs in place (objectui#10887).
  *   - `data` / `variables`   — page data + local variables, for convenience.
  *
  * Styling — page source is metadata, not build input. A react page styles with

package/dist/renderers/navigation/sidebar.d.ts

@@ -6,3 +6,34 @@
  * LICENSE file in the root directory of this source tree.
  */
 export {};
+/**
+ * ⛔ The ten `sidebar-*` node type keys are RETIRED (objectui#10859 batch 8,
+ * phase 2d, the seat's fork ruling on that card, by the objectui#10393 /
+ * objectui#8760 route): `sidebar-provider`, `sidebar-header`,
+ * `sidebar-content`, `sidebar-group`, `sidebar-menu`, `sidebar-menu-item`,
+ * `sidebar-menu-button`, `sidebar-footer`, `sidebar-inset` and
+ * `sidebar-trigger`. The shadcn components behind them (`SidebarProvider`,
+ * `SidebarHeader`, `SidebarMenuButton`, `SidebarTrigger` and the rest) stay
+ * exported from `../../ui` for JSX composition; only the node keys went.
+ *
+ * ## What was here, and why it went
+ *
+ * Ten registrations in the `ui` namespace, one per shadcn part, each storing
+ * `ui:KEY` and the bare `KEY` fallback. (Described rather than quoted: source
+ * readers such as `@object-ui/types`' node-slot test take a quoted call in a
+ * comment for a live one.) Nine rendered their child list into the matching
+ * shadcn part; `sidebar-group` also drew a resolved `label`,
+ * `sidebar-menu-button` passed `size` / `tooltip` through the form-control DOM
+ * declaration, and `sidebar-trigger` rendered the collapse button and no child
+ * list. No `@object-ui/types` arm claims any of them, so `objectui validate`
+ * refused each at `type` while the registry mounted it.
+ *
+ * ## Why unregistering is the whole retirement
+ *
+ * The mainstream ships one app-level sidebar region, not author-composable
+ * parts (the seat's ruling), and nothing wrote these nodes except the four
+ * `components-basic-sidebar` catalog documents, rewritten in the same change to
+ * the `sidebar` node above, which now supplies its own provider. Re-measured
+ * for phase 2d: 0 other producers in source, docs, examples or objectstack, and
+ * 0 runtime emission.
+ */

package/dist/ui/badge.d.ts

@@ -8,7 +8,7 @@ import { VariantProps } from 'class-variance-authority';
  */
 import * as React from "react";
 declare const badgeVariants: (props?: ({
-    variant?: "default" | "destructive" | "outline" | "secondary" | null | undefined;
+    variant?: "default" | "secondary" | "outline" | "destructive" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 export interface BadgeProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
 }

package/dist/ui/button.d.ts

@@ -8,7 +8,7 @@ import { VariantProps } from 'class-variance-authority';
  */
 import * as React from "react";
 declare const buttonVariants: (props?: ({
-    variant?: "link" | "default" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
+    variant?: "link" | "default" | "secondary" | "outline" | "ghost" | "destructive" | null | undefined;
     size?: "default" | "sm" | "lg" | "icon" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {

package/dist/ui/calendar.d.ts

@@ -1,4 +1,5 @@
 import { DayButton, DayPicker } from 'react-day-picker';
+import { CalendarLocaleTagProps } from '../lib/date-fns-locale.js';
 import { Button } from './button.js';
 /**
  * ObjectUI
@@ -8,7 +9,7 @@ import { Button } from './button.js';
  * LICENSE file in the root directory of this source tree.
  */
 import * as React from "react";
-declare function Calendar({ className, classNames, showOutsideDays, captionLayout, buttonVariant, formatters, components, ...props }: React.ComponentProps<typeof DayPicker> & {
+declare function Calendar({ className, classNames, showOutsideDays, captionLayout, buttonVariant, formatters, components, localeTag, ...props }: React.ComponentProps<typeof DayPicker> & CalendarLocaleTagProps & {
     buttonVariant?: React.ComponentProps<typeof Button>["variant"];
 }): React.JSX.Element;
 declare function CalendarDayButton({ className, day, modifiers, ...props }: React.ComponentProps<typeof DayButton>): React.JSX.Element;

package/dist/ui/command.d.ts

@@ -33,7 +33,7 @@ declare const Command: React.ForwardRefExoticComponent<Omit<{
     ref?: React.Ref<HTMLDivElement>;
 } & {
     asChild?: boolean;
-}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild"> & {
+}, "key" | "asChild" | keyof React.HTMLAttributes<HTMLDivElement>> & {
     label?: string;
     shouldFilter?: boolean;
     filter?: (value: string, search: string, keywords?: string[]) => number;
@@ -49,7 +49,7 @@ declare const CommandInput: React.ForwardRefExoticComponent<Omit<Omit<Pick<Pick<
     ref?: React.Ref<HTMLInputElement>;
 } & {
     asChild?: boolean;
-}, "key" | "asChild" | keyof React.InputHTMLAttributes<HTMLInputElement>>, "onChange" | "value" | "type"> & {
+}, "key" | "asChild" | keyof React.InputHTMLAttributes<HTMLInputElement>>, "type" | "value" | "onChange"> & {
     value?: string;
     onValueChange?: (search: string) => void;
 } & React.RefAttributes<HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
@@ -59,7 +59,7 @@ declare const CommandList: React.ForwardRefExoticComponent<Omit<{
     ref?: React.Ref<HTMLDivElement>;
 } & {
     asChild?: boolean;
-}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild"> & {
+}, "key" | "asChild" | keyof React.HTMLAttributes<HTMLDivElement>> & {
     label?: string;
 } & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
 declare const CommandEmpty: React.ForwardRefExoticComponent<Omit<{
@@ -68,14 +68,14 @@ declare const CommandEmpty: React.ForwardRefExoticComponent<Omit<{
     ref?: React.Ref<HTMLDivElement>;
 } & {
     asChild?: boolean;
-}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+}, "key" | "asChild" | keyof React.HTMLAttributes<HTMLDivElement>> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
 declare const CommandGroup: React.ForwardRefExoticComponent<Omit<{
     children?: React.ReactNode;
 } & Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
     ref?: React.Ref<HTMLDivElement>;
 } & {
     asChild?: boolean;
-}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild">, "heading" | "value"> & {
+}, "key" | "asChild" | keyof React.HTMLAttributes<HTMLDivElement>>, "value" | "heading"> & {
     heading?: React.ReactNode;
     value?: string;
     forceMount?: boolean;
@@ -84,7 +84,7 @@ declare const CommandSeparator: React.ForwardRefExoticComponent<Omit<Pick<Pick<R
     ref?: React.Ref<HTMLDivElement>;
 } & {
     asChild?: boolean;
-}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild"> & {
+}, "key" | "asChild" | keyof React.HTMLAttributes<HTMLDivElement>> & {
     alwaysRender?: boolean;
 } & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
 declare const CommandItem: React.ForwardRefExoticComponent<Omit<{
@@ -93,7 +93,7 @@ declare const CommandItem: React.ForwardRefExoticComponent<Omit<{
     ref?: React.Ref<HTMLDivElement>;
 } & {
     asChild?: boolean;
-}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild">, "onSelect" | "disabled" | "value"> & {
+}, "key" | "asChild" | keyof React.HTMLAttributes<HTMLDivElement>>, "disabled" | "value" | "onSelect"> & {
     disabled?: boolean;
     onSelect?: (value: string) => void;
     value?: string;

package/dist/ui/index.d.ts

@@ -16,7 +16,6 @@ export * from './button.js';
 export * from './calendar.js';
 export * from './card.js';
 export * from './carousel.js';
-export * from './chart.js';
 export * from './checkbox.js';
 export * from './collapsible.js';
 export * from './command.js';

package/dist/ui/input-otp.d.ts

@@ -6,7 +6,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 import * as React from "react";
-declare const InputOTP: React.ForwardRefExoticComponent<(Omit<Omit<React.InputHTMLAttributes<HTMLInputElement>, "onChange" | "value" | "maxLength" | "textAlign" | "onComplete" | "pushPasswordManagerStrategy" | "pasteTransformer" | "containerClassName" | "noScriptCSSFallback"> & {
+declare const InputOTP: React.ForwardRefExoticComponent<(Omit<Omit<React.InputHTMLAttributes<HTMLInputElement>, "value" | "onChange" | "maxLength" | "textAlign" | "onComplete" | "pushPasswordManagerStrategy" | "pasteTransformer" | "containerClassName" | "noScriptCSSFallback"> & {
     value?: string;
     onChange?: (newValue: string) => unknown;
     maxLength: number;
@@ -19,7 +19,7 @@ declare const InputOTP: React.ForwardRefExoticComponent<(Omit<Omit<React.InputHT
 } & {
     render: (props: import('input-otp').RenderProps) => React.ReactNode;
     children?: never;
-} & React.RefAttributes<HTMLInputElement>, "ref"> | Omit<Omit<React.InputHTMLAttributes<HTMLInputElement>, "onChange" | "value" | "maxLength" | "textAlign" | "onComplete" | "pushPasswordManagerStrategy" | "pasteTransformer" | "containerClassName" | "noScriptCSSFallback"> & {
+} & React.RefAttributes<HTMLInputElement>, "ref"> | Omit<Omit<React.InputHTMLAttributes<HTMLInputElement>, "value" | "onChange" | "maxLength" | "textAlign" | "onComplete" | "pushPasswordManagerStrategy" | "pasteTransformer" | "containerClassName" | "noScriptCSSFallback"> & {
     value?: string;
     onChange?: (newValue: string) => unknown;
     maxLength: number;

package/dist/ui/sheet.d.ts

@@ -14,7 +14,7 @@ declare const SheetClose: React.ForwardRefExoticComponent<SheetPrimitive.DialogC
 declare const SheetPortal: React.FC<SheetPrimitive.DialogPortalProps>;
 declare const SheetOverlay: React.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
 declare const sheetVariants: (props?: ({
-    side?: "left" | "right" | "top" | "bottom" | null | undefined;
+    side?: "top" | "bottom" | "left" | "right" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 interface SheetContentProps extends React.ComponentPropsWithoutRef<typeof SheetPrimitive.Content>, VariantProps<typeof sheetVariants> {
     hideOverlay?: boolean;

package/dist/ui/sidebar.d.ts

@@ -18,6 +18,7 @@ type SidebarContextProps = {
     toggleSidebar: () => void;
 };
 declare function useSidebar(): SidebarContextProps;
+declare function useOptionalSidebar(): SidebarContextProps | null;
 declare const SidebarProvider: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
     defaultOpen?: boolean;
     open?: boolean;
@@ -69,4 +70,4 @@ declare const SidebarMenuSubButton: React.ForwardRefExoticComponent<Omit<React.C
     size?: "sm" | "md";
     isActive?: boolean;
 }, "ref"> & React.RefAttributes<HTMLAnchorElement>>;
-export { Sidebar, SidebarContent, SidebarFooter, SidebarGroup, SidebarGroupAction, SidebarGroupContent, SidebarGroupLabel, SidebarHeader, SidebarInput, SidebarInset, SidebarMenu, SidebarMenuAction, SidebarMenuBadge, SidebarMenuButton, SidebarMenuItem, SidebarMenuSkeleton, SidebarMenuSub, SidebarMenuSubButton, SidebarMenuSubItem, SidebarProvider, SidebarRail, SidebarSeparator, SidebarTrigger, useSidebar, };
+export { Sidebar, SidebarContent, SidebarFooter, SidebarGroup, SidebarGroupAction, SidebarGroupContent, SidebarGroupLabel, SidebarHeader, SidebarInput, SidebarInset, SidebarMenu, SidebarMenuAction, SidebarMenuBadge, SidebarMenuButton, SidebarMenuItem, SidebarMenuSkeleton, SidebarMenuSub, SidebarMenuSubButton, SidebarMenuSubItem, SidebarProvider, SidebarRail, SidebarSeparator, SidebarTrigger, useSidebar, useOptionalSidebar, };