@arbidocs/blocks 0.3.184 → 0.4.0

package/dist/timeline/index.cjs

@@ -0,0 +1,50 @@
+"use client";
+'use strict';
+
+var chunkELR74ME6_cjs = require('../chunk-ELR74ME6.cjs');
+var chunkVPPX5XUF_cjs = require('../chunk-VPPX5XUF.cjs');
+
+
+
+Object.defineProperty(exports, "Timeline", {
+  enumerable: true,
+  get: function () { return chunkELR74ME6_cjs.Timeline; }
+});
+Object.defineProperty(exports, "TIMELINE_ZOOM", {
+  enumerable: true,
+  get: function () { return chunkVPPX5XUF_cjs.TIMELINE_ZOOM; }
+});
+Object.defineProperty(exports, "TimelineCalendar", {
+  enumerable: true,
+  get: function () { return chunkVPPX5XUF_cjs.TimelineCalendar; }
+});
+Object.defineProperty(exports, "TimelineGantt", {
+  enumerable: true,
+  get: function () { return chunkVPPX5XUF_cjs.TimelineGantt; }
+});
+Object.defineProperty(exports, "TimelineZoomControl", {
+  enumerable: true,
+  get: function () { return chunkVPPX5XUF_cjs.TimelineZoomControl; }
+});
+Object.defineProperty(exports, "dayKey", {
+  enumerable: true,
+  get: function () { return chunkVPPX5XUF_cjs.dayKey; }
+});
+Object.defineProperty(exports, "formatSpan", {
+  enumerable: true,
+  get: function () { return chunkVPPX5XUF_cjs.formatSpan; }
+});
+Object.defineProperty(exports, "monthLabel", {
+  enumerable: true,
+  get: function () { return chunkVPPX5XUF_cjs.monthLabel; }
+});
+Object.defineProperty(exports, "parseIso", {
+  enumerable: true,
+  get: function () { return chunkVPPX5XUF_cjs.parseIso; }
+});
+Object.defineProperty(exports, "utcDay", {
+  enumerable: true,
+  get: function () { return chunkVPPX5XUF_cjs.utcDay; }
+});
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/timeline/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.cjs"}

package/dist/timeline/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Timeline views — one item shape, three ways to read it.
+ *
+ * Everything here renders from its props alone: no SDK, no query client, no
+ * router. A back office feeds it live records; a public site feeds it a literal
+ * array from the page builder. Both get the same component.
+ */
+export type { TimelineItem } from './types';
+export { TimelineCalendar, type TimelineCalendarProps } from './TimelineCalendar';
+export { TimelineGantt, type TimelineGanttProps } from './TimelineGantt';
+export { TimelineZoomControl, TIMELINE_ZOOM, type TimelineZoomControlProps, } from './TimelineZoomControl';
+export { Timeline, type TimelineProps, type TimelineViewMode } from './Timeline';
+export { formatSpan, parseIso, utcDay, dayKey, monthLabel } from './span';

package/dist/timeline/index.js

@@ -0,0 +1,5 @@
+"use client";
+export { Timeline } from '../chunk-OVEQERPO.js';
+export { TIMELINE_ZOOM, TimelineCalendar, TimelineGantt, TimelineZoomControl, dayKey, formatSpan, monthLabel, parseIso, utcDay } from '../chunk-4EZVCGRL.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/timeline/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/timeline/span.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Reading a stored date span back at the precision it was written.
+ *
+ * A span carries no precision flag — "October 2019" and "the whole of October"
+ * are the same thing on a timeline — so precision is inferred from the shape of
+ * the bounds: midnight to 23:59:59 across a month is "Oct 2019", across one day
+ * is that date, a zero-width span is an instant, and anything else is a range.
+ *
+ * Every value is read from its UTC components and NEVER localised. A
+ * day-precision value stored at 00:00Z would otherwise display as the previous
+ * day for every viewer west of UTC — which is also why these helpers spell out
+ * English month names instead of delegating to `Intl`: the formatter's timezone
+ * handling is the exact trap being avoided.
+ */
+export declare const WEEKDAY_NAMES: string[];
+export declare const DAY_MS = 86400000;
+/** Month name and year, e.g. "October 2019". */
+export declare function monthLabel(d: Date): string;
+/** The UTC midnight that starts the day `d` falls in. */
+export declare function utcDay(d: Date): Date;
+/** `YYYY-MM-DD` for the UTC day — a stable key and testid suffix. */
+export declare function dayKey(d: Date): string;
+/** Parse an ISO string, returning null rather than an Invalid Date. */
+export declare function parseIso(iso: string | null | undefined): Date | null;
+/** Format a stored span the way its precision implies. '' when undated.
+ *  `timezone` renders an instant in its recorded zone instead of UTC — pass it
+ *  only where the source actually carries one (e.g. a fact's `timezone`
+ *  field); day-precision spans stay zone-agnostic regardless. */
+export declare function formatSpan(startIso: string | null | undefined, endIso: string | null | undefined, timezone?: string | null): string;

package/dist/timeline/types.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The one shape every timeline view in this package reads.
+ *
+ * A timeline entry is a LABELLED SPAN: something that happened, and the stretch
+ * of time it occupies. An instant is simply a span whose end equals its start —
+ * "5pm" is a moment, not a five-minute window — so callers never have to model
+ * "events" and "periods" as two different things.
+ *
+ * Views are generic over `T extends TimelineItem`, so a caller may hand over its
+ * own richer objects (a note, an order, a booking) and get that exact type back
+ * from `onSelect` and `renderDetail` without a cast.
+ */
+export interface TimelineItem {
+    /** Stable identity. Used as the React key and to track the active row. */
+    id: string;
+    /** One-line label, drawn on the bar and in the row header. */
+    label: string;
+    /** ISO 8601 start of the span. */
+    start: string;
+    /** ISO 8601 end. Omit (or equal `start`) for an instant. */
+    end?: string | null;
+    /** Longer text shown in the detail panel. */
+    description?: string;
+    /**
+     * Up to three CSS colours the bar is painted with — e.g. an item's label
+     * colours. One fills solid; two or three split the bar into equal segments.
+     * Omitted or empty renders a neutral bar; colours past the third are ignored.
+     */
+    colors?: readonly string[];
+}

package/dist/workspaces/WorkspaceBadges.d.ts

@@ -0,0 +1,27 @@
+import type { ComponentType } from 'react';
+export interface RoleBadgeProps {
+    /** Display text (e.g. "Owner"). */
+    label: string;
+    /** Colour classes of the role, supplied by the host so it owns the palette. */
+    badgeClass: string;
+    className?: string;
+}
+/** A user's role in a workspace as a coloured badge. */
+export declare function RoleBadge({ label, badgeClass, className }: RoleBadgeProps): import("react").JSX.Element;
+export interface WorkspaceTypeBadgeViewProps {
+    /** Glyph of the type (person / people / globe). */
+    icon: ComponentType<{
+        className?: string;
+    }>;
+    /** Background class of the type's colour. */
+    bgClass: string;
+    /** Type name (Individual / Group / Common), shown as tooltip. */
+    typeLabel: string;
+    showTooltip?: boolean;
+    size?: 'sm' | 'md';
+    /** Drawn on a selected (coloured) row: adds a white outline. */
+    isSelected?: boolean;
+    className?: string;
+}
+/** Small coloured square telling a workspace's type, optionally with a tooltip. */
+export declare function WorkspaceTypeBadgeView({ icon: Icon, bgClass, typeLabel, showTooltip, size, isSelected, className, }: WorkspaceTypeBadgeViewProps): import("react").JSX.Element;

package/dist/workspaces/WorkspaceCard.d.ts

@@ -0,0 +1,142 @@
+import { type HTMLAttributes, type ReactNode } from 'react';
+import { type StackedMember } from '../components/MemberAvatarStack';
+/** Everything a workspace tile shows, source-agnostic (not the raw SDK shape). */
+export interface WorkspaceSummary {
+    id: string;
+    name: string;
+    description?: string | null;
+    /** Host-supplied line under the name (a reference, a client, a status...). Not interpreted. */
+    subtitle?: ReactNode;
+    docCount: number;
+    /** Hidden when undefined, so a host without chats shows no empty counter. */
+    chatCount?: number;
+    /** Number of visible members (agents excluded by the caller). */
+    memberCount: number;
+    members: StackedMember[];
+    /** The viewer may not see who is here (RLS): renders an em dash, not a `0`. */
+    membersHidden?: boolean;
+    /** ISO timestamp: rendered as "Updated {relative}". */
+    updatedAt?: string | null;
+}
+/** Every fixed string of the workspace tile. Pass a partial `labels` to translate or reword. */
+export interface WorkspaceCardLabels {
+    /** The tile's accessible name. */
+    openWorkspace: (name: string) => string;
+    currentWorkspace: string;
+    documents: string;
+    chats: string;
+    members: string;
+    /** `relative` is the formatted "3 days ago". */
+    updated: (relative: string) => string;
+}
+export declare const DEFAULT_WORKSPACE_CARD_LABELS: WorkspaceCardLabels;
+type DivProps = Omit<HTMLAttributes<HTMLDivElement>, 'children'>;
+export interface WorkspaceCardRootProps extends DivProps {
+    /** This is the workspace you are in: accented surface, "Current workspace" cue. */
+    current?: boolean;
+    onSelect: () => void;
+    /**
+     * Real link target. The tile then renders as an anchor (ctrl-click / new tab, in-SPA through
+     * `BlocksProvider`'s `linkComponent`); `onSelect` still fires on a plain click.
+     */
+    href?: string;
+    /** Accessible name; defaults to `labels.openWorkspace(name)` when composed via `WorkspaceCard`. */
+    label: string;
+    testId?: string;
+    labels?: Partial<WorkspaceCardLabels>;
+    children: ReactNode;
+}
+/**
+ * The tile surface: one button that opens the workspace. Tonal (`bg-muted`, no
+ * border, no shadow); the current workspace takes the selection tint.
+ */
+declare function WorkspaceCardRoot({ current, onSelect, href, label, testId, labels, className, children, ...rest }: WorkspaceCardRootProps): import("react").JSX.Element;
+/** Mark + name + open cue, on one row. Put the entity mark first. */
+declare function WorkspaceCardHeader({ className, children, ...rest }: DivProps & {
+    children: ReactNode;
+}): import("react").JSX.Element;
+declare function WorkspaceCardTitle({ children, className }: {
+    children: ReactNode;
+    className?: string;
+}): import("react").JSX.Element;
+/**
+ * The open cue is always on screen (never hover-only): a chevron, or the words
+ * "Current workspace" on the one you are in.
+ */
+declare function WorkspaceCardOpenCue({ testId, currentLabel, }: {
+    /** Deliberately separate from the card id: suites count cards by prefix. */
+    testId?: string;
+    /** Overrides `labels.currentWorkspace`. */
+    currentLabel?: string;
+}): import("react").JSX.Element;
+declare function WorkspaceCardDescription({ children, className, }: {
+    children: ReactNode;
+    className?: string;
+}): import("react").JSX.Element;
+/** Host-supplied line under the title. */
+declare function WorkspaceCardSubtitle({ className, children, ...rest }: DivProps & {
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** Footer block: stats row and meta line, pinned to the bottom of the tile. */
+declare function WorkspaceCardFooter({ className, children, ...rest }: DivProps & {
+    children: ReactNode;
+}): import("react").JSX.Element;
+export interface WorkspaceCardStatsProps {
+    docCount: number;
+    /** Omit to hide the chats counter. */
+    chatCount?: number;
+    memberCount: number;
+    members?: StackedMember[];
+    membersHidden?: boolean;
+    /** Faces before the rest collapse into `+N`. */
+    maxAvatars?: number;
+    className?: string;
+}
+/** Documents / chats / members counts, with the member faces at the trailing edge. */
+declare function WorkspaceCardStats({ docCount, chatCount, memberCount, members, membersHidden, maxAvatars, className, }: WorkspaceCardStatsProps): import("react").JSX.Element;
+/** "Updated 3 days ago", with the exact date on the title. */
+declare function WorkspaceCardMeta({ updatedAt }: {
+    updatedAt: string;
+}): import("react").JSX.Element;
+export interface WorkspaceCardProps {
+    workspace: WorkspaceSummary;
+    current?: boolean;
+    onSelect: () => void;
+    /** Real link target; see `WorkspaceCard.Root`. */
+    href?: string;
+    /** The entity mark shown before the name (the host's own workspace glyph). */
+    mark?: ReactNode;
+    /** Card id; derived ids: `-title`, `-member-count`, `-member-avatars`. */
+    testId?: string;
+    /** Id for the open cue (kept apart from `testId`, see `WorkspaceCard.OpenCue`). */
+    openCueTestId?: string;
+    maxAvatars?: number;
+    /**
+     * The stats row: omit for the default counts + member faces, `false` to hide it, or any node to
+     * replace it.
+     */
+    stats?: ReactNode | false;
+    /** Reword the tile's fixed strings. */
+    labels?: Partial<WorkspaceCardLabels>;
+    className?: string;
+}
+/**
+ * The workspace tile: mark + name + open cue, description, stats and meta.
+ * The whole tile opens the workspace; nothing on it is hover-only.
+ *
+ * Need a different layout? Compose the parts: `WorkspaceCard.Root`, `.Header`,
+ * `.Title`, `.OpenCue`, `.Subtitle`, `.Description`, `.Footer`, `.Stats`, `.Meta`.
+ */
+declare function WorkspaceCardBase({ workspace, current, onSelect, href, mark, testId, openCueTestId, maxAvatars, stats, labels, className, }: WorkspaceCardProps): import("react").JSX.Element;
+export declare const WorkspaceCard: typeof WorkspaceCardBase & {
+    Root: typeof WorkspaceCardRoot;
+    Header: typeof WorkspaceCardHeader;
+    Title: typeof WorkspaceCardTitle;
+    OpenCue: typeof WorkspaceCardOpenCue;
+    Subtitle: typeof WorkspaceCardSubtitle;
+    Description: typeof WorkspaceCardDescription;
+    Footer: typeof WorkspaceCardFooter;
+    Stats: typeof WorkspaceCardStats;
+    Meta: typeof WorkspaceCardMeta;
+};
+export {};

package/dist/workspaces/WorkspaceFormParts.d.ts

@@ -0,0 +1,98 @@
+import { type ReactNode } from 'react';
+/** Inline error strip of a form. */
+export declare function FormErrorBanner({ message, testId, className, id, }: {
+    message: string;
+    testId?: string;
+    className?: string;
+    /** Lets a field point at this message with `aria-describedby`. */
+    id?: string;
+}): import("react").JSX.Element;
+/** Right-aligned footer row of a form (Cancel + submit). */
+export declare function FormActions({ className, children }: {
+    className?: string;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** Footer row of a modal body, separated by a rule. */
+export declare function ModalActionRow({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+export interface WorkspaceFormModalProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    title: ReactNode;
+    /** Icon before the title. */
+    icon?: ReactNode;
+    /** Optional intro paragraph above the form (first-run welcome). */
+    intro?: ReactNode;
+    testId?: string;
+    /** Visually hidden description. */
+    description?: string;
+    children: ReactNode;
+}
+/** Dialog frame of the create-workspace form: header, optional intro, scrolling body. */
+export declare function WorkspaceFormModal({ open, onOpenChange, title, icon, intro, testId, description, children, }: WorkspaceFormModalProps): import("react").JSX.Element;
+/** One entry of the project picker: identity on the left, optional quota summary on the right. */
+export declare function ProjectOptionRow({ identity, meta }: {
+    identity: ReactNode;
+    meta?: string;
+}): import("react").JSX.Element;
+export interface ProjectPickerOption {
+    id: string;
+    content: ReactNode;
+}
+export interface ProjectPickerProps {
+    value?: string;
+    options: ProjectPickerOption[];
+    onChange: (id: string) => void;
+    /** Adds a "Create new project..." entry. */
+    onCreate?: () => void;
+    disabled?: boolean;
+    readOnly?: boolean;
+    className?: string;
+    labels?: {
+        placeholder: string;
+        create: string;
+    };
+}
+/** The workspace's owning project, as a picker (optionally with a create entry). */
+export declare function ProjectPicker({ value, options, onChange, onCreate, disabled, readOnly, className, labels, }: ProjectPickerProps): import("react").JSX.Element;
+/** Compact CTA on a project row (e.g. Upgrade / Change plan). */
+export declare function ProjectActionButton({ label, onClick, className, testId, }: {
+    label: string;
+    onClick: () => void;
+    className?: string;
+    testId?: string;
+}): import("react").JSX.Element;
+export interface WorkspaceFieldsViewProps {
+    /** `modal` (create flow) or `settings` (editing an existing workspace). */
+    variant?: 'modal' | 'settings';
+    name: string;
+    description: string;
+    onNameChange: (value: string) => void;
+    onDescriptionChange: (value: string) => void;
+    onNameBlur?: () => void;
+    onNameFocus?: () => void;
+    onDescriptionBlur?: () => void;
+    disabled?: boolean;
+    readOnly?: boolean;
+    maxNameLength?: number;
+    /** Id of the form's error message (a `FormErrorBanner id`): the name input is then `aria-invalid`
+     *  and described by it. */
+    errorId?: string;
+    /** Content of the Visibility row (settings only); omit to hide the row. */
+    visibility?: ReactNode;
+    /** Content of the Project row; omit to hide the row. */
+    project?: ReactNode;
+    labels?: Partial<WorkspaceFieldsLabels>;
+}
+export interface WorkspaceFieldsLabels {
+    readOnlyNotice: string;
+    name: string;
+    description: string;
+    visibility: string;
+    project: string;
+    over: (n: number) => string;
+    charsLeft: (n: number) => string;
+}
+/** Name / description / visibility / project rows shared by the create and settings forms. */
+export declare function WorkspaceFieldsView({ variant, name, description, onNameChange, onDescriptionChange, onNameBlur, onNameFocus, onDescriptionBlur, disabled, readOnly, errorId, maxNameLength, visibility, project, labels, }: WorkspaceFieldsViewProps): import("react").JSX.Element;

package/dist/workspaces/WorkspaceGroup.d.ts

@@ -0,0 +1,31 @@
+import type { ReactNode } from 'react';
+export interface WorkspaceListProps {
+    children: ReactNode;
+    className?: string;
+    testId?: string;
+}
+/** The column that stacks workspace groups (padding follows the page gutter). */
+export declare function WorkspaceList({ children, className, testId }: WorkspaceListProps): import("react").JSX.Element;
+export interface WorkspaceGroupProps {
+    /** Group heading: name, count, badges. Plain text on the canvas, no band. */
+    title: ReactNode;
+    isExpanded: boolean;
+    onToggle: () => void;
+    /**
+     * Makes the whole header one target (e.g. open the project panel); the
+     * chevron stays a separate toggle. Adds a trailing `openLabel` affordance.
+     */
+    onOpen?: () => void;
+    /** Words beside the trailing chevron when `onOpen` is set, e.g. "Plans & Usage". */
+    openLabel?: string;
+    /** Muted words on the right of a collapsed group without `onOpen`, e.g. "Show 11 shared workspaces". */
+    collapsedHint?: string;
+    /** The cards, laid out in a responsive grid (1 / 2 / 3 columns). */
+    children: ReactNode;
+    className?: string;
+}
+/**
+ * One collapsible band of workspace tiles under a slim header. The open
+ * affordance is always visible, so nothing is reachable by hover alone.
+ */
+export declare function WorkspaceGroup({ title, isExpanded, onToggle, onOpen, openLabel, collapsedHint, children, className, }: WorkspaceGroupProps): import("react").JSX.Element;

package/dist/workspaces/WorkspaceSettingsParts.d.ts

@@ -0,0 +1,70 @@
+import type { ReactNode } from 'react';
+/**
+ * Page frame of a workspace's home: a bounded column whose ONE scroll region spans the full
+ * width (scrollbar on the outer edge), the inset living on the content inside it. A container,
+ * so children can use `@2xl:` queries.
+ */
+export declare function WorkspacePageFrame({ testId, children }: {
+    testId?: string;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** Tinted card holding the identity bar and the expandable member list. */
+export declare function WorkspaceIdentityPanel({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+export interface WorkspaceProjectSlotProps {
+    testId: string;
+    /** Screen-reader caption ("Project:"): the chip says what it is without a word in front. */
+    caption: string;
+    children: ReactNode;
+}
+/** The project control / chip pinned to the end of the name row. */
+export declare function WorkspaceProjectSlot({ testId, caption, children }: WorkspaceProjectSlotProps): import("react").JSX.Element;
+/** Stated absence ("None") rather than a blank gap. */
+export declare function ItalicNone({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+export interface WorkspaceAudienceLineProps {
+    visibility: {
+        testId: string;
+        caption: string;
+        /** The owner's visibility switch (developers only). */
+        toggle?: ReactNode;
+        /** The state named in words, so the switch is never a puzzle. */
+        stateText: string;
+    };
+    /** Member avatar stack. */
+    members: ReactNode;
+    /** "Share" button (owners). */
+    share?: {
+        label: string;
+        onClick: () => void;
+        testId: string;
+    };
+}
+/** Visibility and members end the description line together: who can see and use the workspace. */
+export declare function WorkspaceAudienceLine({ visibility, members, share }: WorkspaceAudienceLineProps): import("react").JSX.Element;
+/**
+ * Collapsible block under the identity bar. Stays mounted and animates its height (grid-rows
+ * 0fr to 1fr), so opening and closing glides instead of snapping.
+ */
+export declare function ExpandableSection({ expanded, testId, children, }: {
+    expanded: boolean;
+    testId?: string;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** Centered loading placeholder of a page body. */
+export declare function PageLoading({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+export interface LeaveFooterProps {
+    testId?: string;
+    leave: {
+        label: string;
+        disabled?: boolean;
+        onClick: () => void;
+        testId?: string;
+    };
+}
+/** Leaving ENDS your part in the workspace, so it sits last and alone at the foot of the page. */
+export declare function LeaveFooter({ testId, leave }: LeaveFooterProps): import("react").JSX.Element;