@crewlethq/ui 0.54.1 → 0.56.0

package/dist/MessageBubble-GKO6X3QG.css

@@ -0,0 +1,71 @@
+/*
+ * One message: the bubble on its writer's side, and what it carried and its
+ * quiet foot under it, on the same side, a spacing step below.
+ */
+.crewlet-message {
+  display: flex;
+  flex-direction: column;
+  gap: var(--spacing-1);
+  min-width: 0;
+  max-width: 85%;
+}
+
+.crewlet-message--self {
+  align-self: flex-end;
+  align-items: flex-end;
+}
+
+.crewlet-message--other {
+  align-self: flex-start;
+  align-items: flex-start;
+}
+
+.crewlet-message__bubble {
+  max-width: 100%;
+  padding: var(--spacing-2) var(--spacing-3);
+  font-size: var(--font-size-compact);
+  line-height: var(--font-line-height-normal);
+  color: var(--color-text-primary);
+  overflow-wrap: anywhere;
+  white-space: pre-wrap;
+}
+
+/* The reader's own: the raised ground, no edge, the tail at the end corner. */
+.crewlet-message--self .crewlet-message__bubble {
+  border-radius: var(--radius-lg) var(--radius-lg) var(--radius-xs) var(--radius-lg);
+  background: var(--color-surface-elevated);
+}
+
+/* Anybody else's: the card ground inside a hairline, the tail at the start corner. */
+.crewlet-message--other .crewlet-message__bubble {
+  border: 1px solid var(--color-border-default);
+  border-radius: var(--radius-lg) var(--radius-lg) var(--radius-lg) var(--radius-xs);
+  background: var(--color-surface-subtle);
+}
+
+.crewlet-message__attachment,
+.crewlet-message__footer {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: var(--spacing-2);
+  font-size: var(--font-size-xs);
+  color: var(--color-text-tertiary);
+}
+
+.crewlet-message--enter {
+  animation: crewlet-message-enter var(--motion-duration-moderate) var(--motion-easing-out);
+}
+
+@keyframes crewlet-message-enter {
+  from {
+    opacity: 0;
+    transform: translateY(var(--spacing-1));
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .crewlet-message--enter {
+    animation: none;
+  }
+}

package/dist/Modal/index.js

@@ -1,9 +1,10 @@
-export { ConfirmModal, Modal } from '../chunk-YCC2S7DF.js';
+export { ConfirmModal, Modal } from '../chunk-QZ4B72FP.js';
 import '../chunk-PQADV6P6.js';
+import '../chunk-HD4QJ2SI.js';
+import '../chunk-EA23JG6R.js';
 import '../chunk-OMV5W53A.js';
-import '../chunk-OG6CL3EB.js';
 import '../chunk-H5XTJ7GJ.js';
-import '../chunk-LACA4JGC.js';
+import '../chunk-2BQYODY3.js';
 import '../chunk-NUZHC6MM.js';
 import '../chunk-BZFWDIV6.js';
 import '../chunk-ODEQTPFM.js';

package/dist/OpenInAppCard/OpenInAppCard.d.ts

@@ -0,0 +1,44 @@
+import type { HTMLAttributes, ReactNode } from 'react';
+/** Whether the place has been opened from the card yet. */
+export type OpenInAppState = 'ready' | 'opened';
+export interface OpenInAppCardLabels {
+    /** The card's title. */
+    heading: string;
+    openHere: string;
+    openInNewTab: string;
+    /** The Tag once opened. */
+    opened: string;
+    /** The strip once opened. */
+    openedNotice: string;
+}
+export declare const OPEN_IN_APP_CARD_LABELS: OpenInAppCardLabels;
+export interface OpenInAppCardProps extends Omit<HTMLAttributes<HTMLElement>, 'title'> {
+    /** The place's glyph, drawn on a neutral tile. */
+    icon: ReactNode;
+    /** The record's own name: "Fix the flaky sign-in test". */
+    title: string;
+    /** Where it lives, as its last two crumbs: "Tasks › ENG-156". */
+    path: string;
+    /**
+     * The address, for Open in new tab. Only a same-application route (`#/...`)
+     * or an http, https or mailto address is drawn as a link; anything else
+     * draws no new-tab link at all.
+     */
+    href: string;
+    /** Opens the place beside the conversation. */
+    onOpenHere: () => void;
+    state?: OpenInAppState | undefined;
+    labels?: Partial<OpenInAppCardLabels> | undefined;
+}
+/**
+ * A place in the product the answer points to, opened only by the person's
+ * press: the record's glyph on a neutral tile, its name and where it lives,
+ * then Open in new tab and Open here. Once opened, a success Tag in the head
+ * and a strip that says where it opened.
+ *
+ * THE ONLY WAY AN ANSWER NAVIGATES. Links written into an answer's prose are
+ * never live; a place is reached through this card, whose address the host
+ * built and checked. The address is checked again here: a scheme other than
+ * the application's own routes, http, https or mailto draws no link.
+ */
+export declare function OpenInAppCard({ icon, title, path, href, onOpenHere, state, labels: overrides, className, ...rest }: OpenInAppCardProps): import("react").JSX.Element;

package/dist/OpenInAppCard/index.d.ts

@@ -0,0 +1,3 @@
+import './OpenInAppCard.css';
+export { OPEN_IN_APP_CARD_LABELS, OpenInAppCard } from './OpenInAppCard.js';
+export type { OpenInAppCardLabels, OpenInAppCardProps, OpenInAppState } from './OpenInAppCard.js';

package/dist/OpenInAppCard/index.js

@@ -0,0 +1,15 @@
+export { OPEN_IN_APP_CARD_LABELS, OpenInAppCard } from '../chunk-YY445YFQ.js';
+import '../chunk-XQI2OUV4.js';
+import '../chunk-BAKPMH3S.js';
+import '../chunk-3LI4TRUR.js';
+import '../chunk-WDIVALLP.js';
+import '../chunk-KYIAFNU7.js';
+import '../chunk-WIATRXEJ.js';
+import '../chunk-INHXF2CL.js';
+import '../chunk-AV2DXAEL.js';
+import '../chunk-BHHIIK3M.js';
+import '../chunk-PQADV6P6.js';
+import '../chunk-HD4QJ2SI.js';
+import '../chunk-EA23JG6R.js';
+import '../chunk-BZFWDIV6.js';
+import '../chunk-ODEQTPFM.js';

package/dist/OpenInAppCard-CKHCK7DO.css

@@ -0,0 +1,24 @@
+/* The place: its tile, then its name over where it lives. */
+.crewlet-open-in-app-card__place {
+  display: flex;
+  align-items: center;
+  gap: var(--spacing-3);
+  min-width: 0;
+}
+
+.crewlet-open-in-app-card__words {
+  display: flex;
+  flex-direction: column;
+  min-width: 0;
+}
+
+.crewlet-open-in-app-card__title {
+  overflow-wrap: anywhere;
+  font-weight: var(--font-weight-medium);
+  color: var(--color-text-primary);
+}
+
+.crewlet-open-in-app-card__path {
+  font-size: var(--font-size-xs);
+  color: var(--color-text-tertiary);
+}

package/dist/OrgTable/index.js

@@ -1,5 +1,5 @@
-export { OrgTable, OrgTableActions, OrgTableAdd, OrgTableName } from '../chunk-XP7EXNKF.js';
-import '../chunk-ON2E46DX.js';
+export { OrgTable, OrgTableActions, OrgTableAdd, OrgTableName } from '../chunk-GPW4M4OI.js';
+import '../chunk-VRNUKH2W.js';
 import '../chunk-MY374UUD.js';
 import '../chunk-ONQKKHON.js';
 import '../chunk-LM3ISVJA.js';
@@ -8,7 +8,7 @@ import '../chunk-PZKHBB7D.js';
 import '../chunk-TROLVEZY.js';
 import '../chunk-OMV5W53A.js';
 import '../chunk-H5XTJ7GJ.js';
-import '../chunk-LACA4JGC.js';
+import '../chunk-2BQYODY3.js';
 import '../chunk-NUZHC6MM.js';
 import '../chunk-BZFWDIV6.js';
 import '../chunk-ODEQTPFM.js';

package/dist/PeekRail/PeekHost.d.ts

@@ -0,0 +1,90 @@
+/**
+ * The one peek in an application, mounted by its frame, and the order a list
+ * publishes for it to step through.
+ *
+ * # Why the frame and not the screen
+ *
+ * A rail rendered by whichever screen wanted one meant exactly one screen had
+ * one. Mounted by the frame it is the opposite: no screen renders a peek and
+ * every screen has one. A list opens it by naming what it points at, and an
+ * address that names a peek opens the same thing on arrival.
+ *
+ * # Stepping belongs to the list, not to the rail
+ *
+ * Previous and Next walk the rows the reader is actually looking at (sorted,
+ * filtered and paged as they left them), and only the list knows that order.
+ * So a list PUBLISHES its order with `usePeekNeighbours` and the rail steps
+ * through it; a list that publishes nothing gets a rail with no stepper
+ * rather than one that steps through something else.
+ *
+ * The order is a list of TOKENS, the host's own identity for an object (kind
+ * and id, say), rather than the rows themselves: the rail needs identity and
+ * nothing else, and handing it rows would make every list's row type part of
+ * the frame's contract.
+ */
+import { type ReactNode } from 'react';
+import { type PeekRailProps } from './PeekRail.js';
+/** What a list publishes: the order it draws, and what its rows' own pages carry. */
+export interface PeekOrder {
+    tokens: readonly string[];
+    /**
+     * The query a page opened from this list carries, such as the list's own
+     * filter, which is what lets an object's page say "3 of 18" and step to the
+     * next. Only an object IN the list carries it.
+     */
+    query?: Readonly<Record<string, string>> | undefined;
+}
+/** Holds the order the list on screen published. Mounted once, around the frame. */
+export declare function PeekNeighbours({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** The order the list on screen published; empty where none did. */
+export declare function usePeekOrder(): PeekOrder;
+/**
+ * Publish the order Previous and Next should walk.
+ *
+ * KEYED ON THE TOKENS rather than on the array, because a list rebuilds its
+ * rows on every push: an effect depending on the array itself would republish
+ * several times a second and re-render the rail with it. The list that
+ * published last owns the stepper, and unmounting clears it, so a rail opened
+ * from the next screen does not step through the last one's rows.
+ */
+export declare function usePeekNeighbours(tokens: readonly string[], query?: Readonly<Record<string, string>>): void;
+/**
+ * The step Previous and Next take from `current` through the published
+ * order, or undefined where there is nothing to step through: no list
+ * published an order, `current` is not in it, or it is the only row.
+ *
+ * A STEP MOVES THE PEEK, it does not open another: the host's `move` should
+ * REPLACE its address entry, so four objects walked through one open rail are
+ * one place the reader has been and Back leaves the list.
+ *
+ * Exported for a list whose own widget takes the keys (a tree that reads every
+ * printable key as type-ahead), so there is one stepper and one order.
+ */
+export declare function usePeekStep(current: string | null, move: (token: string) => void): ((delta: -1 | 1) => void) | undefined;
+export interface PeekHostProps extends Omit<PeekRailProps, 'label' | 'onStep' | 'openHref' | 'onClose' | 'children'> {
+    /** The token of the object the peek is open on, read from the host's address; null when closed. */
+    current: string | null;
+    /**
+     * The body for an object, or undefined where this build has none for its
+     * kind (a hand-edited or out-of-date address), which closes the rail rather
+     * than opening it empty.
+     */
+    render: (token: string) => ReactNode | undefined;
+    /** Names the rail for an object: "Task detail". */
+    label: (token: string) => string;
+    /** Closes the peek: the host removes it from its address. */
+    onClose: () => void;
+    /** Moves the peek to another object: the host REPLACES its address entry. */
+    onMove: (token: string) => void;
+    /**
+     * The object's own page for the Open link, with the query of the list it
+     * was opened from when it is in that list; undefined for no Open (an object
+     * whose page is the list under the rail).
+     */
+    openHref?: ((token: string, query: Readonly<Record<string, string>> | undefined) => string | undefined) | undefined;
+    /** Wraps the body, keyed on the object, in the host's own error boundary. */
+    boundary?: ((token: string, body: ReactNode) => ReactNode) | undefined;
+}
+export declare function PeekHost({ current, render, label, onClose, onMove, openHref, boundary, ...rail }: PeekHostProps): import("react").JSX.Element | null;

package/dist/PeekRail/PeekRail.d.ts

@@ -0,0 +1,83 @@
+/**
+ * The peek: one object, beside whatever list the reader found it in.
+ *
+ * A list opens it by naming what it points at, and it shows that object's
+ * facts in a rail beside the list rather than sending the reader away to read
+ * one title. The rail has a bar (step to the previous or next row, open the
+ * object's own page, close) and a scrolling body.
+ *
+ * # Where it stands
+ *
+ * A column of the shell's sheet beside the scroller (`AppShell` `peek`) while
+ * the window holds the list at its floor beside it, and a drawer over the
+ * page below that, behind a veil a press on which closes it. Which one is the
+ * host's arithmetic (`AppShell` `peekShape`), never a media query: the width
+ * that leaves the list its floor depends on everything else in the frame and
+ * on the density. The drawer is not modal: the list under it stays live, as
+ * it is beside the column.
+ *
+ * # Width
+ *
+ * The width is the host's (`width`), dragged on the grip between `minWidth`
+ * and `maxWidth` and kept per viewer with `useStoredWidth`. As a column it is
+ * capped at what leaves the list `reserve` wide, so a width dragged on a wide
+ * window never takes a narrower one's list away. The grip is a separator with
+ * a value, so the keyboard sizes it as well as the pointer.
+ *
+ * # What the host keeps
+ *
+ * The address (which object, opening pushes and stepping replaces), the
+ * keys that step and close from anywhere on the page, and the body for each
+ * kind of object. `PeekHost` wires the generic half of that; the rail itself
+ * draws and closes.
+ */
+import { type ReactNode } from 'react';
+import { type AppShellPeekShape } from '../AppShell/regions.js';
+/** The rail's resting width, in px, beside a list. */
+export declare const PEEK_RAIL_WIDTH = 420;
+/** The narrowest a reader may drag it, in px. */
+export declare const PEEK_RAIL_MIN_WIDTH = 330;
+/** The widest, in px. */
+export declare const PEEK_RAIL_MAX_WIDTH = 640;
+export interface PeekRailLabels {
+    previous: string;
+    next: string;
+    close: string;
+    open: string;
+    resize: string;
+    /** The tooltip on Previous, where it says more than the name: "Previous ([)". */
+    previousHint?: string | undefined;
+    /** The tooltip on Next: "Next (])". */
+    nextHint?: string | undefined;
+    /** The tooltip on Close: "Close (esc)". */
+    closeHint?: string | undefined;
+}
+export declare const PEEK_RAIL_LABELS: PeekRailLabels;
+export interface PeekRailProps {
+    /** Names the rail: "Task detail". */
+    label: string;
+    /** Where it stands; in the shell's peek slot the shell's `peekShape` is the default. */
+    shape?: AppShellPeekShape | undefined;
+    /** The width, in px. */
+    width?: number | undefined;
+    minWidth?: number | undefined;
+    maxWidth?: number | undefined;
+    /** The resting width a reset (Enter on the grip, a double press) returns to. */
+    defaultWidth?: number | undefined;
+    /** The list's floor beside a column, in px: the rail is capped at what leaves the list this wide. */
+    reserve?: number | undefined;
+    /** Every change of width while a drag or a key moves it. Given one, the column draws its grip. */
+    onWidthChange?: ((width: number) => void) | undefined;
+    /** Where a resize ends: the moment to keep the reader's width. */
+    onWidthCommit?: ((width: number) => void) | undefined;
+    /** Closes the rail: its Close, the veil behind a drawer, Escape from inside it. */
+    onClose: () => void;
+    /** Steps to the previous or next row of the list it was opened from; without it there is no stepper. */
+    onStep?: ((delta: -1 | 1) => void) | undefined;
+    /** The object's own page, for the bar's Open link. Without it there is no Open. */
+    openHref?: string | undefined;
+    labels?: Partial<PeekRailLabels> | undefined;
+    className?: string | undefined;
+    children: ReactNode;
+}
+export declare function PeekRail({ label, shape: asked, width, minWidth, maxWidth, defaultWidth, reserve, onWidthChange, onWidthCommit, onClose, onStep, openHref, labels, className, children, }: PeekRailProps): import("react").JSX.Element;

package/dist/PeekRail/activation.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Which clicks on a row mean "peek here" and which mean "open elsewhere".
+ *
+ * A ROW IS A REAL LINK EITHER WAY: its `href` is the object's page, so a
+ * middle press and a modified press open a tab and the status bar says where
+ * it goes. A plain primary press is intercepted and peeks instead, because the
+ * list is where the reader is.
+ *
+ * ONE COPY, because two spellings of "which clicks mean elsewhere" is how one
+ * of them comes to forget the middle button.
+ */
+import type { MouseEvent as ReactMouseEvent } from 'react';
+import type { DataGridActivationEvent } from '../DataGrid/index.js';
+/** Whether a press is a plain primary press, the one a row answers in place. */
+export declare function isPlainPress(event: Pick<MouseEvent, 'button' | 'metaKey' | 'ctrlKey' | 'shiftKey' | 'altKey' | 'defaultPrevented'>): boolean;
+/**
+ * A row's click, for a row that is an anchor: a plain press calls `open` and
+ * prevents the navigation, and every way a reader opens a tab is left to the
+ * browser. Undefined where there is nothing to open.
+ */
+export declare function peekClickHandler(open?: () => void): ((event: ReactMouseEvent) => void) | undefined;
+/**
+ * A `DataGrid` row's `onRowActivate`, wired to peek.
+ *
+ * A KEYBOARD ACTIVATION HAS NO BUTTON TO READ, so it opens unconditionally:
+ * Enter on a row is the reader saying "this row" with nothing to say
+ * "elsewhere" with. Read through `isPlainPress`, its missing button would read
+ * as a press of another button and the keyboard path would open nothing.
+ */
+export declare function peekRowActivation<T>(open: (row: T) => void): (row: T, event: DataGridActivationEvent) => void;

package/dist/PeekRail/index.d.ts

@@ -0,0 +1,8 @@
+import '../HitArea/HitArea.css';
+import '../AppShell/ResizeHandle.css';
+import './PeekRail.css';
+export { PEEK_RAIL_LABELS, PEEK_RAIL_MAX_WIDTH, PEEK_RAIL_MIN_WIDTH, PEEK_RAIL_WIDTH, PeekRail } from './PeekRail.js';
+export type { PeekRailLabels, PeekRailProps } from './PeekRail.js';
+export { PeekHost, PeekNeighbours, usePeekNeighbours, usePeekOrder, usePeekStep } from './PeekHost.js';
+export type { PeekHostProps, PeekOrder } from './PeekHost.js';
+export { isPlainPress, peekClickHandler, peekRowActivation } from './activation.js';

package/dist/PeekRail/index.js

@@ -0,0 +1,8 @@
+export { PEEK_RAIL_LABELS, PEEK_RAIL_MAX_WIDTH, PEEK_RAIL_MIN_WIDTH, PEEK_RAIL_WIDTH, PeekHost, PeekNeighbours, PeekRail, isPlainPress, peekClickHandler, peekRowActivation, usePeekNeighbours, usePeekOrder, usePeekStep } from '../chunk-LXYSWQNE.js';
+import '../chunk-PIYJNCN7.js';
+import '../chunk-HD4QJ2SI.js';
+import '../chunk-EA23JG6R.js';
+import '../chunk-2YTOOH3A.js';
+import '../chunk-2BQYODY3.js';
+import '../chunk-BZFWDIV6.js';
+import '../chunk-ODEQTPFM.js';

package/dist/PeekRail-4L5YUQMW.css

@@ -0,0 +1,95 @@
+/*
+ * The peek (`PeekRail`): a rail beside the list it was opened from, on the
+ * subtle ground, with a bar at the page bar's height and a scrolling body.
+ *
+ * Its shape is an attribute with one value (`data-shape`), decided by the
+ * host, so there is no width at which it is both a column and a drawer, or
+ * neither. Its width is one variable (`--crewlet-peek-rail-width`), written
+ * on the rail by the component, so the column and the drawer read the same
+ * value and cannot disagree about how wide it is.
+ */
+
+.crewlet-peek-rail {
+  position: relative;
+  display: flex;
+  flex-direction: column;
+  min-width: 0;
+  min-height: 0;
+  background: var(--color-surface-subtle);
+  border-left: 1px solid var(--color-border-hover);
+}
+
+/*
+ * A COLUMN beside the scroller: the reader's width, capped at what leaves the
+ * list its floor (`--crewlet-peek-rail-reserve`, the gutter, the padding, any
+ * section column and the list). At the threshold the host decided the column
+ * at, the cap is exactly the resting width, so the column never opens
+ * narrower than the width it was decided at.
+ */
+.crewlet-peek-rail[data-shape='column'] {
+  flex: none;
+  width: min(var(--crewlet-peek-rail-width), max(0px, 100% - var(--crewlet-peek-rail-reserve, 0px)));
+}
+
+/* The grip straddles the rail's hairline, a little narrower than the frame's
+   seam, since it stands over one line rather than in a gap. */
+.crewlet-peek-rail > .crewlet-resize-handle--left {
+  --crewlet-resize-handle-width: calc(var(--spacing-1) + var(--spacing-1) / 2);
+  left: calc(var(--crewlet-resize-handle-width) / -2);
+}
+
+/* The bar stands at the page bar's height, so the two lines meet. */
+.crewlet-peek-rail__bar {
+  display: flex;
+  flex: none;
+  align-items: center;
+  gap: var(--spacing-1);
+  height: var(--size-shell-topbar);
+  padding: 0 var(--spacing-2);
+  border-bottom: 1px solid var(--color-border-hover);
+}
+
+.crewlet-peek-rail__spacer {
+  flex: 1 1 auto;
+}
+
+/* THE PEEK'S OWN SCROLLER, and a SIZE container for the reason the shell's
+   `main` is one: a record inside a peek is bounded by what the peek shows
+   (`100cqb`), and with no size container between it and the root `cqb`
+   falls back to the viewport, which counts the peek's bar as view. Its
+   height is the flex column's, never its content's, so containing it costs
+   nothing. */
+.crewlet-peek-rail__body {
+  container: crewlet-peek-rail / size;
+  flex: 1 1 auto;
+  min-height: 0;
+  overflow-y: auto;
+  padding: 0 var(--spacing-4) var(--spacing-6);
+}
+
+/*
+ * THE DRAWER: below the host's threshold the rail slides over the page
+ * behind a veil, and a fixed box takes no room, so the page stays one column
+ * under it. No grip: there is no list beside it to give way.
+ */
+/*
+ * Beside an aside column the drawer and its veil stop at the page sheet's
+ * edge (`--crewlet-app-shell-aside-occupied`, measured by the shell), so the
+ * peek stands over the page, next to the aside, rather than over the aside.
+ */
+.crewlet-peek-rail[data-shape='drawer'] {
+  position: fixed;
+  top: 0;
+  right: var(--crewlet-app-shell-aside-occupied, 0px);
+  bottom: 0;
+  z-index: var(--z-index-overlay);
+  width: min(var(--crewlet-peek-rail-width), 92vw);
+  box-shadow: var(--shadow-md);
+}
+
+.crewlet-peek-rail__veil {
+  position: fixed;
+  inset: 0 var(--crewlet-app-shell-aside-occupied, 0px) 0 0;
+  z-index: calc(var(--z-index-overlay) - 1);
+  background: var(--color-surface-veil);
+}

package/dist/PeopleRail/index.js

@@ -1,11 +1,12 @@
-export { PEOPLE_RAIL_LABELS, PeopleRail, peopleRailKey } from '../chunk-3RCHEFIL.js';
+export { PEOPLE_RAIL_LABELS, PeopleRail, peopleRailKey } from '../chunk-ICJRP6QW.js';
 import '../chunk-CENOOTAV.js';
 import '../chunk-Z7JYG5TF.js';
 import '../chunk-AYKXMIOR.js';
 import '../chunk-5AQBPHZD.js';
 import '../chunk-PZKHBB7D.js';
 import '../chunk-PQADV6P6.js';
-import '../chunk-OG6CL3EB.js';
-import '../chunk-LACA4JGC.js';
+import '../chunk-HD4QJ2SI.js';
+import '../chunk-EA23JG6R.js';
+import '../chunk-2BQYODY3.js';
 import '../chunk-BZFWDIV6.js';
 import '../chunk-ODEQTPFM.js';

package/dist/PinTile/index.js

@@ -1,4 +1,4 @@
-export { PinTile } from '../chunk-OJCVVCAZ.js';
-import '../chunk-LACA4JGC.js';
+export { PinTile } from '../chunk-JMMS2PQU.js';
+import '../chunk-2BQYODY3.js';
 import '../chunk-BZFWDIV6.js';
 import '../chunk-ODEQTPFM.js';

package/dist/PresenterView/index.js

@@ -1,11 +1,12 @@
-export { PresenterView, formatStopwatch } from '../chunk-E6HXFFWO.js';
-import '../chunk-RRO7UEYU.js';
+export { PresenterView, formatStopwatch } from '../chunk-EGL24VY5.js';
+import '../chunk-OHBXOEP3.js';
 import '../chunk-RMEBFYL7.js';
 import '../chunk-RK4XPHVG.js';
+import '../chunk-HD4QJ2SI.js';
+import '../chunk-EA23JG6R.js';
 import '../chunk-OMV5W53A.js';
-import '../chunk-OG6CL3EB.js';
 import '../chunk-H5XTJ7GJ.js';
-import '../chunk-LACA4JGC.js';
+import '../chunk-2BQYODY3.js';
 import '../chunk-NUZHC6MM.js';
 import '../chunk-BZFWDIV6.js';
 import '../chunk-ODEQTPFM.js';

package/dist/PrincipalPicker/index.js

@@ -1,16 +1,16 @@
-export { PrincipalPicker } from '../chunk-G5SUSCWL.js';
-import '../chunk-C6Z3MLSA.js';
+export { PrincipalPicker } from '../chunk-TA72CURM.js';
+import '../chunk-U5PJSGHG.js';
 import '../chunk-7KHM2FZH.js';
 import '../chunk-CI3VPIJN.js';
 import '../chunk-5AQBPHZD.js';
 import '../chunk-PZKHBB7D.js';
-import '../chunk-LJHH4WWB.js';
+import '../chunk-FXQLNETQ.js';
 import '../chunk-XCUUI7E7.js';
 import '../chunk-PQADV6P6.js';
 import '../chunk-RSAQOKH3.js';
 import '../chunk-2YTOOH3A.js';
 import '../chunk-H5XTJ7GJ.js';
-import '../chunk-LACA4JGC.js';
+import '../chunk-2BQYODY3.js';
 import '../chunk-NUZHC6MM.js';
 import '../chunk-BZFWDIV6.js';
 import '../chunk-ODEQTPFM.js';