@autono/pinbox-toolbar 0.1.0 → 0.8.0

package/dist/vue.d.ts

@@ -1,4 +1,4 @@
-import { d as PinboxToolbarElement, n as PinboxConfig } from "./index-ZR3JBQu-.js";
+import { d as PinboxToolbarElement, n as PinboxConfig } from "./index-BAoi0bRT.js";
 import { VNode } from "vue";
 //#region src/vue.d.ts
 /** The slice of the Vue component instance this wrapper touches. */

package/dist/vue.js

@@ -1,4 +1,4 @@
-import { n as defineToolbarElement, r as PinboxToolbarElement } from "./src-BoLg81_j.js";
+import { n as defineToolbarElement, r as PinboxToolbarElement } from "./src-D1qn1iet.js";
 import { h } from "vue";
 //#region src/vue.ts
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autono/pinbox-toolbar",
-  "version": "0.1.0",
+  "version": "0.8.0",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -71,7 +71,7 @@
     }
   },
   "devDependencies": {
-    "@autono/pinbox-core": "0.0.0",
+    "@autono/pinbox-core": "0.8.0",
     "@types/react": "^19.2.0",
     "typescript": "^7.0.0",
     "tsdown": "^0.22.0",

package/dist/index-ZR3JBQu-.d.ts

@@ -1,206 +0,0 @@
-import { Attachment, Pin, PinInput, ThreadMessage } from "@autono/pinbox-core/schema";
-//#region src/capture.d.ts
-/**
- * The full browser shapes. `Pin["target"]`/`Pin["env"]` are optional at v1 (core
- * schema.ts §"widened in place") because a terminal `pinbox pin` has no browser to
- * measure. A capture is the opposite case: it always has a window, so it always
- * produces every field. Narrowing here is what keeps every capture-side consumer
- * free of optional chaining — the widening only reaches code that reads pins back.
- */
-type MaybeTarget = NonNullable<Pin["target"]>;
-type MaybeEnv = NonNullable<Pin["env"]>;
-/** The named keys become present-and-defined; everything else keeps its optionality. */
-type Concrete<T, K extends keyof T> = T & { [P in K]-?: NonNullable<T[P]>; };
-type BrowserTarget = Concrete<MaybeTarget, "url" | "selector" | "tag" | "rect" | "fixed">;
-type BrowserEnv = Concrete<MaybeEnv, "viewport" | "browser" | "os" | "colorScheme">;
-/** What a targeting adapter produces for a chosen element: the pin schema shapes. */
-interface CaptureResult {
-  target: BrowserTarget;
-  env: BrowserEnv;
-}
-//#endregion
-//#region src/state.d.ts
-type UiStatus = "open" | "waiting" | "replied" | "resolved" | "verify";
-interface Draft {
-  target: CaptureResult;
-  placedAt: {
-    x: number;
-    y: number;
-  };
-}
-interface ToolbarState {
-  pins: Pin[];
-  threads: Map<string, ThreadMessage[]>;
-  draft: Draft | null;
-  mode: "idle" | "placing";
-  activePinId: string | null;
-  inboxOpen: boolean;
-  connection: "connecting" | "live" | "offline" | "incompatible";
-  /** Outbox-queued pin ids (offline creates) — flagged "queued" in the UI until the flush. */
-  queuedIds: ReadonlySet<string>;
-}
-interface Store {
-  get(): ToolbarState;
-  /** Render subscribes once; every update() notifies each subscriber exactly once. */
-  subscribe(fn: (state: ToolbarState) => void): () => void;
-  update(patch: Partial<ToolbarState>): void;
-  /** Placement click: sets the draft and leaves placing mode. Client-only — no hub call. */
-  place(draft: Draft): void;
-  /** Abandoned draft: cleared without touching pins; nothing ever reached the hub. */
-  discardDraft(): void;
-  /** First comment submitted: the hub-created Pin replaces the draft and becomes active. */
-  commitDraft(pin: Pin): void;
-}
-declare function createStore(): Store;
-/** Replace-by-id upsert; new pins append. */
-declare function upsertPin(store: Store, pin: Pin): void;
-/** Append to the pin's thread, deduping by message id (REST echo vs WS event). */
-declare function appendThreadMessage(store: Store, message: ThreadMessage): void;
-/**
- * Wire events mutate the store: pin.created upserts;
- * pin.resolved / pin.verified / pin.linked replace the payload Pin;
- * thread.message appends — payloads are the full post-mutation objects.
- */
-declare function applyHubEvent(store: Store, event: {
-  seq: number;
-  eventType: string;
-  at: string;
-  payload: unknown;
-}): void;
-/**
- * Wire-status → UI-status mapping:
- * resolved + no verification ⇒ "verify" (accept/reopen prompt);
- * resolved + verification ⇒ "resolved";
- * open + empty thread or last message human ⇒ "waiting";
- * open + last message agent|mirror ⇒ "replied".
- * The prototype's WORKING/APPLIED chips need an event vocabulary the hub does not emit — excluded here.
- */
-declare function deriveUiStatus(pin: Pin, thread: ThreadMessage[]): UiStatus;
-//#endregion
-//#region src/element.d.ts
-declare const BaseElement: typeof HTMLElement;
-declare class PinboxToolbarElement extends BaseElement {
-  #private;
-  static readonly tagName = "pinbox-toolbar";
-  readonly store: Store;
-  /** Card → transport seam (wired by #startTransport once a config exists). */
-  readonly actions: {
-    send?: (pinId: string | "draft", text: string) => void;
-    verify?: (pinId: string, outcome: "accepted" | "reopened") => void;
-    resolve?: (pinId: string) => void;
-  };
-  /** Programmatic path (Pinbox.init). The snippet path reads hub/token attributes. */
-  configure(config: PinboxConfig): void;
-  get config(): PinboxConfig | null;
-  connectedCallback(): void;
-  disconnectedCallback(): void;
-}
-//#endregion
-//#region src/transport/mirror.d.ts
-interface StorageLike {
-  getItem(key: string): string | null;
-  setItem(key: string, value: string): void;
-  removeItem(key: string): void;
-}
-//#endregion
-//#region src/transport/rest.d.ts
-type FetchLike = (input: string, init?: RequestInit) => Promise<Response>;
-declare class HubError extends Error {
-  readonly code: string;
-  readonly status: number;
-  readonly hint: string | undefined;
-  constructor(code: string, message: string, status: number, hint?: string);
-}
-//#endregion
-//#region src/transport.d.ts
-/** The browser WebSocket surface the transport needs — injectable for tests. */
-interface WebSocketLike {
-  send(data: string): void;
-  close(code?: number, reason?: string): void;
-  onopen: (() => void) | null;
-  onmessage: ((ev: {
-    data: string;
-  }) => void) | null;
-  onclose: ((ev: {
-    code: number;
-  }) => void) | null;
-  onerror: (() => void) | null;
-}
-interface SchedulerLike {
-  setTimeout(fn: () => void, ms: number): unknown;
-  clearTimeout(id: unknown): void;
-}
-interface HubEvent {
-  seq: number;
-  eventType: string;
-  at: string;
-  payload: unknown;
-}
-type ConnectionState = "connecting" | "live" | "offline" | "incompatible";
-interface TransportOptions {
-  endpoint: string;
-  token: string;
-  /** Default localStorage; injectable for tests. */
-  storage?: StorageLike;
-  /** Injectable for tests. */
-  webSocket?: (url: string, protocols: string[]) => WebSocketLike;
-  onEvent(e: HubEvent): void;
-  onConnection(state: ConnectionState): void;
-  /** Reconciled pin lists: fresh `listPins()` after each reconnect (hub wins on status). */
-  onPins?(pins: Pin[]): void;
-  /** Queued outbox localIds whenever the set changes — the UI flags them as pending sync. */
-  onOutbox?(localIds: string[]): void;
-  /** Test seam; default global fetch. */
-  fetchFn?: FetchLike;
-  /** Test seam standing in for fake timers; default global setTimeout/clearTimeout. */
-  scheduler?: SchedulerLike;
-}
-declare class HubTransport {
-  #private;
-  /** Stable per install, persisted (`pinbox:<endpoint>:consumer`). */
-  readonly consumerId: string;
-  constructor(opts: TransportOptions);
-  /** Last-known pin list — the offline read-only render seed. */
-  mirrorPins(): Pin[];
-  /** Optimistic pins for the queued outbox — offline reloads render + flag them. */
-  outboxPins(): Pin[];
-  /** Last-known thread for a pin — the offline read-only thread render seed.
-   * Empty for a pin whose thread was never fetched while connected. */
-  mirrorThread(pinId: string): ThreadMessage[];
-  /** hello → buffer live frames → apply catch-up → drain buffer. */
-  connect(): void;
-  close(): void;
-  listPins(): Promise<Pin[]>;
-  /** Offline ⇒ queued in the outbox, optimistic local pin (client wins on new pins). */
-  createPin(input: PinInput): Promise<Pin>;
-  /** Mirrored on every success, served from the mirror when the hub is unreachable —
-   * an offline reload renders read-only threads instead of empty ones. Any other
-   * hub error (auth, not-found) surfaces: the mirror is a fallback, not a mask. */
-  getThread(pinId: string): Promise<ThreadMessage[]>;
-  reply(pinId: string, text: string, attachments?: Attachment[]): Promise<ThreadMessage>;
-  resolve(pinId: string, note?: string): Promise<Pin>;
-  verify(pinId: string, outcome: "accepted" | "reopened"): Promise<Pin>;
-}
-//#endregion
-//#region src/index.d.ts
-interface PinboxConfig {
-  /** Hub base URL. */
-  endpoint: string;
-  /** Local dev: injected by the dev plugin. */
-  token?: string;
-  /** Cloud: the host app supplies (spec: auth passthrough). */
-  getToken?: () => Promise<string>;
-  /** Default "dom"; "anchor" for sandboxed cross-origin iframe hosts (Task 7). */
-  targeting?: "dom" | "anchor";
-  /** Anchor mode attribute, default "data-pb-anchor". */
-  anchorAttribute?: string;
-  /** Reserved; the realtime topic is fixed server-side. */
-  project?: string;
-}
-/** Register <pinbox-toolbar>; no-op outside a browser or when already defined. */
-declare function defineToolbarElement(): void;
-declare const Pinbox: {
-  init(config: PinboxConfig): PinboxToolbarElement;
-};
-//#endregion
-export { applyHubEvent as _, HubEvent as a, upsertPin as b, WebSocketLike as c, PinboxToolbarElement as d, Draft as f, appendThreadMessage as g, UiStatus as h, ConnectionState as i, HubError as l, ToolbarState as m, PinboxConfig as n, HubTransport as o, Store as p, defineToolbarElement as r, TransportOptions as s, Pinbox as t, StorageLike as u, createStore as v, CaptureResult as x, deriveUiStatus as y };