@crewlethq/ui 0.17.0 → 0.18.0

package/dist/PresenceStack/PresenceStack.d.ts

@@ -0,0 +1,36 @@
+import { type AvatarSizeStep } from '../Avatar/index.js';
+import { type PresenceLabels, type PresenceMember } from '../PresenceModel/index.js';
+export interface PresenceStackProps {
+    /** Everybody present but the reader, in the order they joined. The stack orders them by activity. */
+    members: readonly PresenceMember[];
+    /** Whether the reader is present too, which is what the accessible name counts from: "You and 3 others are here". */
+    self?: boolean | undefined;
+    /** How many badges are drawn before the rest are counted in a chip. Four by default. */
+    max?: number | undefined;
+    size?: AvatarSizeStep | undefined;
+    /**
+     * Makes each badge a button: a host opens its own menu from it ("Follow
+     * Maya", "Open turn"). Without it the stack is one image with one name.
+     */
+    onSelect?: ((member: PresenceMember) => void) | undefined;
+    /** The stack's accessible name, where the derived one is not what it means where it stands. */
+    label?: string | undefined;
+    labels?: Partial<PresenceLabels> | undefined;
+    className?: string | undefined;
+}
+/**
+ * Who is here, at a glance: the badges of everybody present in an artifact,
+ * people editing first, then agents editing, people viewing, agents reading,
+ * and anybody idle last.
+ *
+ * A PRESENT BADGE WEARS A RING IN THE COLLABORATOR'S HUE, the same hue their
+ * cursor and cell outline are drawn in, which is how a reader matches a ring
+ * on a cell to a face in the stack. It is the presence colour exception (D22):
+ * the badge carries the name, and the ring is never the only carrier. An idle
+ * collaborator's badge loses its ring and fades, and says "Idle" in words.
+ *
+ * Built on the avatar stack's own geometry (the overlap, the cut-out ring in
+ * the ground's colour, the counted chip), so a presence stack and a stack of
+ * watchers beside it are one mark.
+ */
+export declare function PresenceStack({ members, self, max, size, onSelect, label, labels, className }: PresenceStackProps): import("react").JSX.Element | null;

package/dist/PresenceStack/index.d.ts

@@ -0,0 +1,3 @@
+import './PresenceStack.css';
+export { PresenceStack } from './PresenceStack.js';
+export type { PresenceStackProps } from './PresenceStack.js';

package/dist/PresenceStack/index.js

@@ -0,0 +1,9 @@
+export { PresenceStack } from '../chunk-YM3GJHGW.js';
+import '../chunk-CENOOTAV.js';
+import '../chunk-I6POAB4V.js';
+import '../chunk-S35G6PNC.js';
+import '../chunk-AYKXMIOR.js';
+import '../chunk-UAN5NE7M.js';
+import '../chunk-5OM447RW.js';
+import '../chunk-BZFWDIV6.js';
+import '../chunk-ODEQTPFM.js';

package/dist/PresenceStack-QSXQJND5.css

@@ -0,0 +1,59 @@
+/*
+ * Who is here (PresenceStack.tsx), on the avatar stack's own geometry: the
+ * overlap and the counted chip are the stack's. What this adds is the ring in
+ * each present collaborator's hue, outside the cut-out, and the idle fade.
+ */
+
+/* The wrapper (a span, or a button when badges select) carries no edge of its
+   own: the cut-out and the hue ring are drawn on the badge inside it, which
+   has the badge's own outline to follow. */
+.crewlet-presence-stack > .crewlet-presence-stack__member {
+  display: inline-flex;
+  flex: none;
+  padding: 0;
+  border: 0;
+  background: none;
+  box-shadow: none;
+  color: inherit;
+  font: inherit;
+}
+
+.crewlet-presence-stack > .crewlet-presence-stack__member--human {
+  border-radius: var(--radius-circle);
+}
+
+.crewlet-presence-stack > .crewlet-presence-stack__member--agent {
+  border-radius: var(--radius-sm);
+}
+
+button.crewlet-presence-stack__member {
+  cursor: pointer;
+}
+
+button.crewlet-presence-stack__member:focus-visible {
+  outline: 2px solid var(--color-focus);
+  outline-offset: var(--size-focus-ring-inset-offset);
+}
+
+.crewlet-presence-stack .crewlet-presence-stack__badge {
+  box-shadow: 0 0 0 2px var(--crewlet-avatar-stack-ground);
+}
+
+/* The hue ring sits outside the cut-out, so it reads as a ring round the
+   badge rather than a stroke on it. */
+.crewlet-presence-stack .crewlet-presence-stack__badge--present {
+  box-shadow:
+    0 0 0 2px var(--crewlet-avatar-stack-ground),
+    0 0 0 4px var(--crewlet-presence-hue);
+}
+
+.crewlet-presence-stack .crewlet-presence-stack__badge--idle {
+  opacity: 0.5;
+}
+
+@media (forced-colors: active) {
+  .crewlet-presence-stack .crewlet-presence-stack__badge--present {
+    outline: 2px solid Highlight;
+    outline-offset: 2px;
+  }
+}

package/dist/PricingCard/index.js

@@ -1,4 +1,4 @@
-export { PricingCard } from '../chunk-UCYIRDND.js';
-import '../chunk-LOECRMHA.js';
+export { PricingCard } from '../chunk-DQSXWQMJ.js';
+import '../chunk-GFV4LJHH.js';
 import '../chunk-WIATRXEJ.js';
 import '../chunk-ODEQTPFM.js';

package/dist/Principal/Principal.d.ts

@@ -0,0 +1,35 @@
+import type { CrewletCharacterId } from '@crewlethq/icons/characters';
+import { type AvatarSize } from '../Avatar/index.js';
+import type { NodeHue } from '../utils/nodeHue.js';
+/**
+ * Who something is shared with, made by or owned by.
+ *
+ * `person` and `agent` are seats (a person holds a human seat), drawn as the
+ * circle and the squircle `Avatar` already draws them as. A `team` is an org
+ * unit: everyone in it and below it, people and agents alike, so it is drawn
+ * with the people glyph rather than anybody's initials.
+ */
+export type PrincipalKind = 'person' | 'agent' | 'team';
+export declare const PRINCIPAL_KINDS: readonly ["person", "agent", "team"];
+export interface Principal {
+    /** Stable across renames: a seat handle or a unit key. */
+    id: string;
+    kind: PrincipalKind;
+    name: string;
+    /** A short second line: a unit, a handle, "6 people, 4 agents". */
+    detail?: string | undefined;
+    /** The Crewlet character an agent is drawn as. */
+    character?: CrewletCharacterId | undefined;
+    /** The hue an agent's character is drawn in. */
+    hue?: NodeHue | undefined;
+    /** A person's picture. */
+    src?: string | undefined;
+}
+export interface PrincipalAvatarProps {
+    principal: Principal;
+    size?: AvatarSize | undefined;
+    /** The name is printed beside the badge, so the badge says nothing itself. Defaults to true. */
+    decorative?: boolean | undefined;
+}
+/** A principal's badge, drawn the one way every surface draws it. */
+export declare function PrincipalAvatar({ principal, size, decorative }: PrincipalAvatarProps): import("react").JSX.Element;

package/dist/Principal/index.d.ts

@@ -0,0 +1,2 @@
+export { PRINCIPAL_KINDS, PrincipalAvatar } from './Principal.js';
+export type { Principal, PrincipalAvatarProps, PrincipalKind } from './Principal.js';

package/dist/Principal/index.js

@@ -0,0 +1,4 @@
+export { PRINCIPAL_KINDS, PrincipalAvatar } from '../chunk-4KP4RC3O.js';
+import '../chunk-UAN5NE7M.js';
+import '../chunk-5OM447RW.js';
+import '../chunk-ODEQTPFM.js';

package/dist/PrincipalPicker/PrincipalPicker.d.ts

@@ -0,0 +1,45 @@
+import { type Principal, type PrincipalKind } from '../Principal/index.js';
+/** A principal that may be offered but not taken, with the reason in words. */
+export interface PrincipalOption extends Principal {
+    disabled?: boolean | undefined;
+    /** Why it cannot be picked: "Already has access", "Only a person can add the whole company". */
+    disabledReason?: string | undefined;
+}
+export interface PrincipalPickerLabels {
+    /** The heading over each kind's group of suggestions. */
+    groups: Record<PrincipalKind, string>;
+    empty: string;
+    loading: string;
+}
+export interface PrincipalPickerProps {
+    /** What the field holds. The caller owns it, and searches with it. */
+    query: string;
+    onQueryChange: (query: string) => void;
+    /**
+     * The matches for `query`, in any order: they are grouped people, then
+     * agents, then teams. The caller filters, because who matches is the
+     * engine's answer, not a substring of a list the browser happens to hold.
+     */
+    options: readonly PrincipalOption[];
+    onPick: (principal: Principal) => void;
+    /** Names the field and its list. */
+    label: string;
+    placeholder?: string | undefined;
+    /** A search is in flight; the list says so instead of saying nobody matches. */
+    loading?: boolean | undefined;
+    disabled?: boolean | undefined;
+    className?: string | undefined;
+    labels?: Partial<PrincipalPickerLabels> | undefined;
+}
+/**
+ * A search over people, agents and teams, with each match drawn as itself.
+ *
+ * THE LIST IS GROUPED BY KIND, because "Operations" the team and "Operations
+ * Lead" the agent are different answers to "who should see this", and a flat
+ * list of names makes a reader stop on every row to find out which is which.
+ * The groups are real ARIA groups named by their headings, and the highlight
+ * still moves through every option in order, across the groups.
+ *
+ * Picking clears the field, ready for the next name.
+ */
+export declare function PrincipalPicker({ query, onQueryChange, options, onPick, label, placeholder, loading, disabled, className, labels, }: PrincipalPickerProps): import("react").JSX.Element;

package/dist/PrincipalPicker/index.d.ts

@@ -0,0 +1,3 @@
+import './PrincipalPicker.css';
+export { PrincipalPicker } from './PrincipalPicker.js';
+export type { PrincipalOption, PrincipalPickerLabels, PrincipalPickerProps } from './PrincipalPicker.js';

package/dist/PrincipalPicker/index.js

@@ -0,0 +1,12 @@
+export { PrincipalPicker } from '../chunk-3UAA4IWJ.js';
+import '../chunk-ZFH7H7GS.js';
+import '../chunk-F73MC7EZ.js';
+import '../chunk-4GB57WIT.js';
+import '../chunk-4FQT6ZAY.js';
+import '../chunk-R25RGPUB.js';
+import '../chunk-4KP4RC3O.js';
+import '../chunk-UAN5NE7M.js';
+import '../chunk-5OM447RW.js';
+import '../chunk-PQADV6P6.js';
+import '../chunk-BZFWDIV6.js';
+import '../chunk-ODEQTPFM.js';

package/dist/PrincipalPicker-7NNZTGUP.css

@@ -0,0 +1,41 @@
+/*
+ * The suggestions under the field, grouped by kind. A row is the badge and the
+ * name with its second line, the shape every list of principals in the
+ * product draws.
+ */
+
+.crewlet-principal-picker {
+  flex: 1 1 auto;
+  min-width: 0;
+}
+
+.crewlet-principal-picker__group + .crewlet-principal-picker__group {
+  margin-top: var(--spacing-1);
+  padding-top: var(--spacing-1);
+  border-top: 1px solid var(--color-border-default);
+}
+
+.crewlet-principal-picker__heading {
+  padding: var(--spacing-1) var(--spacing-2);
+  color: var(--color-text-tertiary);
+  font-size: var(--font-size-xs);
+  font-weight: var(--font-weight-medium);
+}
+
+.crewlet-principal-picker__option {
+  display: flex;
+  align-items: center;
+  gap: var(--spacing-2);
+}
+
+.crewlet-principal-picker__text {
+  display: flex;
+  flex-direction: column;
+  min-width: 0;
+}
+
+.crewlet-principal-picker__name {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}

package/dist/SandboxedFrame/SandboxedFrame.d.ts

@@ -0,0 +1,142 @@
+import { type HTMLAttributes } from 'react';
+import { type FrameBridgeRange, type FrameHello, type FrameOriginMode, type FrameTheme } from '../FrameProtocol/index.js';
+/**
+ * Where the frame is in its life.
+ *
+ * `loading` until the document has said hello, `ready` once it holds a port,
+ * and four ends, each torn down rather than left showing a document nobody
+ * vouched for: `failed` (it never said hello), `navigated` (a document that did
+ * not say hello replaced one that had), `refused` (the policy it arrived with
+ * is not one this host embeds) and `outdated` (it speaks no bridge version
+ * this host does).
+ */
+export type SandboxedFrameState = 'loading' | 'ready' | 'failed' | 'navigated' | 'refused' | 'outdated';
+/**
+ * Something the host turned away, reported so the page around the frame can
+ * record it. None of these is shown to the reader as more than the frame's
+ * own state: they are evidence for whoever reads the logs.
+ */
+export type FrameRefusal = 
+/** The engine's sandbox attribute carried tokens this host never sets. */
+{
+    kind: 'sandbox';
+    tokens: string[];
+}
+/** The frame URL is not http or https, or is not served from the origin it was given. */
+ | {
+    kind: 'src';
+}
+/** The nonce handed to the frame is not the shape the engine mints. */
+ | {
+    kind: 'nonce';
+}
+/** The embedded window said hello from the wrong origin. */
+ | {
+    kind: 'origin';
+    origin: string;
+}
+/** The embedded window said hello with a nonce that is not this frame's. */
+ | {
+    kind: 'hello-nonce';
+}
+/** A second hello without a document load between, or any second hello on the shared host. */
+ | {
+    kind: 'rehello';
+}
+/** The runtime speaks no bridge version this host does. */
+ | {
+    kind: 'bridge';
+    offered: FrameBridgeRange;
+}
+/** The page asked to open something that is not an external http, https or mailto link. */
+ | {
+    kind: 'link';
+    url: string;
+};
+export interface SandboxedFrameLabels {
+    /** The loading line, said once to a screen reader and drawn under the placeholder. */
+    loading: (title: string) => string;
+    failed: string;
+    failedDetail: string;
+    navigated: string;
+    navigatedDetail: string;
+    refused: string;
+    refusedDetail: string;
+    outdated: string;
+    outdatedDetail: string;
+    reload: string;
+}
+/** How long a document has to say hello after the frame mounts, or after a load, before it is torn down. */
+export declare const FRAME_HELLO_TIMEOUT_MS = 10000;
+type FrameDivAttributes = Omit<HTMLAttributes<HTMLDivElement>, 'title' | 'onMessage' | 'children' | 'role' | 'aria-label'>;
+export interface SandboxedFrameProps extends FrameDivAttributes {
+    /** The engine's ticketed frame URL (`Frame.frame_url`). The host appends the fragment. */
+    src: string;
+    /**
+     * The origin the document is served from (`Frame.origin`). Per artifact, the
+     * hello must come from exactly this origin. On the shared host the document
+     * is opaque, its hello comes from `"null"`, and this may be that host's
+     * origin or `"null"` itself.
+     */
+    origin: string;
+    /** How the engine isolated the artifact (`Frame.mode`). */
+    mode: FrameOriginMode;
+    /** The engine's sandbox attribute (`Frame.sandbox`), set verbatim once it passes the host's own check. */
+    sandbox: string;
+    /** The engine's permissions attribute (`Frame.allow`), set verbatim. */
+    allow?: string | undefined;
+    /** The artifact's title. It names the frame, and the region around it, to assistive technology. */
+    title: string;
+    /**
+     * The reader's appearance. The value at mount goes in the fragment, so the
+     * first paint is already right; later values are posted on the port.
+     */
+    theme: FrameTheme;
+    /** The handshake nonce minted with the ticket (`Frame.nonce`). */
+    nonce: string;
+    /** The document said hello and holds its port. Called again for each document that does. */
+    onReady?: ((port: MessagePort, hello: FrameHello) => void) | undefined;
+    /** Every port message the frame does not handle itself. UNTRUSTED input: decide every call. */
+    onMessage?: ((data: unknown, port: MessagePort) => void) | undefined;
+    /**
+     * The page asked to open an external link. The frame never opens a window
+     * itself: the page around it shows the destination first (`LinkInterstitial`).
+     */
+    onOpenLink?: ((url: URL) => void) | undefined;
+    /**
+     * The page asked to give focus back, which is how a reader leaves a page
+     * that traps Tab. Without a handler, focus moves to the frame's region.
+     */
+    onFocusExit?: (() => void) | undefined;
+    onStateChange?: ((state: SandboxedFrameState) => void) | undefined;
+    onRefusal?: ((refusal: FrameRefusal) => void) | undefined;
+    /** Offered on every end state as the Reload action. Mint a fresh frame, then re-render with it. */
+    onReload?: (() => void) | undefined;
+    helloTimeoutMs?: number | undefined;
+    labels?: Partial<SandboxedFrameLabels> | undefined;
+}
+/**
+ * An artifact's document, embedded in a sandboxed frame and spoken to over one
+ * transferred `MessagePort`.
+ *
+ * THE HANDSHAKE IS THE WHOLE SECURITY OF THE BRIDGE. A hello is accepted only
+ * from this iframe's own window, carrying the nonce minted with its ticket,
+ * and, per artifact, from the artifact's own origin. Only then is a fresh
+ * port transferred, in the same task, to the window that was checked. Every
+ * later call travels on that port, which no other window can address, and a
+ * document that navigates away loses it.
+ *
+ * A DOCUMENT THAT DOES NOT ANNOUNCE ITSELF IS TORN DOWN. The engine's runtime
+ * says hello on every load, so a load with no hello means the frame now holds
+ * a document the engine did not serve, and the frame is removed rather than
+ * left on screen. On the shared host, where origins are opaque, a document
+ * gets one handshake per ticket; a second document needs a fresh ticket.
+ *
+ * The frame never opens a window: an external link reaches `onOpenLink`, and
+ * the page around the frame decides.
+ *
+ * A new `src` or `nonce` is a new frame: everything is torn down and started
+ * again, as if the component had been remounted.
+ */
+export declare function SandboxedFrame(props: SandboxedFrameProps): import("react").JSX.Element;
+export {};

package/dist/SandboxedFrame/index.d.ts

@@ -0,0 +1,3 @@
+import './SandboxedFrame.css';
+export { FRAME_HELLO_TIMEOUT_MS, SandboxedFrame } from './SandboxedFrame.js';
+export type { FrameRefusal, SandboxedFrameLabels, SandboxedFrameProps, SandboxedFrameState } from './SandboxedFrame.js';

package/dist/SandboxedFrame/index.js

@@ -0,0 +1,8 @@
+export { FRAME_HELLO_TIMEOUT_MS, SandboxedFrame } from '../chunk-VYDFB6PJ.js';
+import '../chunk-W5J7R5EB.js';
+import '../chunk-F6V2PTN6.js';
+import '../chunk-ZXXDZJQN.js';
+import '../chunk-SVSCLHHI.js';
+import '../chunk-OG6CL3EB.js';
+import '../chunk-BZFWDIV6.js';
+import '../chunk-ODEQTPFM.js';

package/dist/SandboxedFrame-L6HBQZCD.css

@@ -0,0 +1,50 @@
+/*
+ * The frame fills the box it is given. The page around it does not scroll
+ * round the artifact: the artifact scrolls inside its own document, which is
+ * what a viewer body that holds one wants.
+ *
+ * The region takes focus when the frame hands it back, and keeps the
+ * document's own focus treatment then: a reader who just left a page by
+ * keyboard needs to see where they landed.
+ */
+
+.crewlet-sandboxed-frame {
+  position: relative;
+  display: flex;
+  flex-direction: column;
+  width: 100%;
+  height: 100%;
+  min-height: 0;
+  overflow: hidden;
+  border-radius: var(--radius-md);
+  background: var(--color-surface-background);
+}
+
+.crewlet-sandboxed-frame__frame {
+  flex: 1 1 auto;
+  display: block;
+  width: 100%;
+  height: 100%;
+  border: 0;
+  background: transparent;
+}
+
+/* Kept out of sight while it starts, so a document that has not painted in
+   the reader's palette yet is never what they see. It still loads. */
+.crewlet-sandboxed-frame[data-state='loading'] .crewlet-sandboxed-frame__frame {
+  visibility: hidden;
+}
+
+.crewlet-sandboxed-frame__loading {
+  position: absolute;
+  inset: 0;
+  display: flex;
+  padding: var(--spacing-3);
+}
+
+.crewlet-sandboxed-frame__end {
+  display: flex;
+  flex-direction: column;
+  justify-content: flex-start;
+  padding: var(--spacing-4);
+}

package/dist/ShareDialog/ShareDialog.d.ts

@@ -0,0 +1,101 @@
+import { type ReactNode } from 'react';
+import { type Principal } from '../Principal/index.js';
+import { type ArtifactRole, type CompanyAccess, type ShareableRole } from './roles.js';
+/** One line of "Who has access". */
+export interface ShareAudienceRow {
+    /** Stable for the row: the share's id, or the principal's key for an effective row. */
+    id: string;
+    principal: Principal;
+    role: ArtifactRole;
+    /** The reader's own row, drawn with "(you)". */
+    self?: boolean | undefined;
+    /**
+     * Access this principal holds THROUGH something else ("Through Operations",
+     * "Everyone in Acme"). An effective row is not a share: it carries no role
+     * control and no remove, because changing it means changing what it is
+     * through.
+     */
+    via?: string | undefined;
+    /** A change to this row is in flight; the row says so until the engine answers. */
+    pending?: boolean | undefined;
+    /** The engine refused the last change to this row, in words ("Only a person can share with the whole company."). */
+    refusal?: string | undefined;
+    /** The role can be changed here. Defaults to true for a direct share that is not the owner. */
+    editable?: boolean | undefined;
+    /** The row can be removed here. Defaults to `editable`. */
+    removable?: boolean | undefined;
+    /** A line under the row. An agent's row says what the agent may do with its role when this is left out. */
+    note?: string | undefined;
+}
+export interface ShareDialogLabels {
+    title: (artifact: string) => string;
+    addRole: string;
+    audience: string;
+    you: string;
+    roles: Record<ArtifactRole, string>;
+    roleDescriptions: Record<ArtifactRole, string>;
+    roleFor: (name: string) => string;
+    remove: (name: string) => string;
+    saving: string;
+    /** Why a row's controls wait while its change is in flight. */
+    busy: string;
+    /** What an agent may do in its turns with each role. */
+    agentNote: (name: string, role: ArtifactRole) => string;
+    companyAccess: string;
+    company: (company: string, access: CompanyAccess) => string;
+    copyLink: string;
+    linkCopied: string;
+    linkNote: string;
+    done: string;
+}
+export interface ShareDialogProps {
+    open: boolean;
+    onClose: () => void;
+    /** The artifact's title, named in the dialog's own. */
+    title: string;
+    /**
+     * The grantee search, given the role the reader chose for whoever they add.
+     * A `PrincipalPicker` wired to the engine's search, as a rule: picking
+     * somebody there is the add, at that role.
+     */
+    picker?: ((context: {
+        role: ShareableRole;
+    }) => ReactNode) | undefined;
+    /** The role a new grantee starts at. The least by default. */
+    defaultAddRole?: ShareableRole | undefined;
+    /** The roles this reader may grant, in ladder order. Every shareable role by default. */
+    grantableRoles?: readonly ShareableRole[] | undefined;
+    audience: readonly ShareAudienceRow[];
+    onRoleChange?: ((row: ShareAudienceRow, role: ShareableRole) => void) | undefined;
+    onRemove?: ((row: ShareAudienceRow) => void) | undefined;
+    companyName: string;
+    companyAccess: CompanyAccess;
+    onCompanyAccessChange?: ((access: CompanyAccess) => void) | undefined;
+    companyPending?: boolean | undefined;
+    companyRefusal?: string | undefined;
+    /** The artifact's address inside the dashboard. Access is still the engine's decision on every open. */
+    link?: string | undefined;
+    /** The reader may see who has access but not change it. The reason is said in place of every control. */
+    readOnly?: {
+        reason: string;
+    } | undefined;
+    /** A line above everything else: "You can manage this because you are an administrator." */
+    note?: ReactNode;
+    labels?: Partial<ShareDialogLabels> | undefined;
+}
+/**
+ * Who can open an artifact, and at what role, with the controls to change it.
+ *
+ * CHANGES ARE CONFIRMED, NOT OPTIMISTIC. A role change or a removal is asked
+ * of the engine and the row shows it is saving until the engine answers; a
+ * refusal is said on the row it belongs to, in the engine's words. Nothing
+ * here pretends a share happened before it did.
+ *
+ * A READER WHO CANNOT SHARE STILL SEES WHO CAN OPEN IT. The dialog opens in
+ * read mode with the reason, every role as words, and no control: a write is
+ * never hidden, and neither is the audience.
+ *
+ * Owner is not offered by any control: it moves only by transfer, in the
+ * artifact's settings.
+ */
+export declare function ShareDialog({ open, onClose, title, picker, defaultAddRole, grantableRoles, audience, onRoleChange, onRemove, companyName, companyAccess, onCompanyAccessChange, companyPending, companyRefusal, link, readOnly, note, labels, }: ShareDialogProps): import("react").JSX.Element;

package/dist/ShareDialog/index.d.ts

@@ -0,0 +1,5 @@
+import './ShareDialog.css';
+export { ShareDialog } from './ShareDialog.js';
+export type { ShareAudienceRow, ShareDialogLabels, ShareDialogProps } from './ShareDialog.js';
+export { ARTIFACT_ROLES, roleAtLeast, SHAREABLE_ROLES } from './roles.js';
+export type { ArtifactRole, CompanyAccess, ShareableRole } from './roles.js';

package/dist/ShareDialog/index.js

@@ -0,0 +1,19 @@
+export { ARTIFACT_ROLES, SHAREABLE_ROLES, ShareDialog, roleAtLeast } from '../chunk-2YR5ZPQ3.js';
+import '../chunk-FC4YTTFJ.js';
+import '../chunk-2TZATTIU.js';
+import '../chunk-F73MC7EZ.js';
+import '../chunk-W46LPU4R.js';
+import '../chunk-STJ7QBC3.js';
+import '../chunk-DTIW4CHZ.js';
+import '../chunk-SVSCLHHI.js';
+import '../chunk-OG6CL3EB.js';
+import '../chunk-IG75YMUN.js';
+import '../chunk-4FQT6ZAY.js';
+import '../chunk-HMPFGIWM.js';
+import '../chunk-R25RGPUB.js';
+import '../chunk-4KP4RC3O.js';
+import '../chunk-UAN5NE7M.js';
+import '../chunk-5OM447RW.js';
+import '../chunk-PQADV6P6.js';
+import '../chunk-BZFWDIV6.js';
+import '../chunk-ODEQTPFM.js';

package/dist/ShareDialog/roles.d.ts

@@ -0,0 +1,10 @@
+export type ArtifactRole = 'viewer' | 'commenter' | 'contributor' | 'editor' | 'owner';
+/** The roles a share may grant: every role but owner. */
+export type ShareableRole = Exclude<ArtifactRole, 'owner'>;
+/** The ladder in ascending order. */
+export declare const ARTIFACT_ROLES: readonly ["viewer", "commenter", "contributor", "editor", "owner"];
+export declare const SHAREABLE_ROLES: readonly ["viewer", "commenter", "contributor", "editor"];
+/** Whether `role` includes `floor`: an editor can do everything a viewer can. */
+export declare function roleAtLeast(role: ArtifactRole, floor: ArtifactRole): boolean;
+/** What the whole company may do: nothing beyond the people added, or one shareable role. */
+export type CompanyAccess = 'none' | ShareableRole;