@inkbar/vue 0.0.0-stage → 0.2.0

package/dist/composables/useAnnotations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAnnotations.d.ts","sourceRoot":"","sources":["../../src/composables/useAnnotations.ts"],"names":[],"mappings":"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"}

package/dist/composables/useAnnotations.js

@@ -0,0 +1,27 @@
+import { useInkContext as e } from "../context.js";
+import { computed as t } from "vue";
+import { acceptSuggestion as n, repliesTo as r } from "@inkbar/core";
+//#region src/composables/useAnnotations.ts
+function i() {
+	let i = e("useAnnotations()"), a = () => i.document.value?.annotations;
+	return {
+		annotations: i.annotations,
+		selection: i.selection,
+		selected: t(() => i.selection.value.map((e) => i.annotations.value.find((t) => t.id === e)).filter((e) => !!e)),
+		byPage: (e) => i.annotations.value.filter((t) => t.page === e),
+		add: (e) => a()?.add(e),
+		update: (e, t) => a()?.update(e, t),
+		remove: (e) => a()?.remove(e) ?? !1,
+		select: (e) => a()?.select(e),
+		replies: (e) => r(i.annotations.value, e),
+		accept: (e) => {
+			let t = a();
+			return t ? n(t, e) : void 0;
+		},
+		dismiss: (e) => a()?.remove(e) ?? !1
+	};
+}
+//#endregion
+export { i as useAnnotations };
+
+//# sourceMappingURL=useAnnotations.js.map

package/dist/composables/useAnnotations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAnnotations.js","names":["useAnnotations","ctx","useInkContext","store","computed","a","id","page","input","patch","ids","repliesTo","s","acceptSuggestion"],"sources":["../../src/composables/useAnnotations.ts"],"sourcesContent":["import { acceptSuggestion, repliesTo } from '@inkbar/core'\nimport { computed } from 'vue'\n\nimport { useInkContext } from '../context'\n\nimport type { Annotation, AnnotationInput } from '@inkbar/core'\n\nexport function useAnnotations() {\n  const ctx = useInkContext('useAnnotations()')\n  const store = () => ctx.document.value?.annotations\n  return {\n    annotations: ctx.annotations,\n    selection: ctx.selection,\n    selected: computed(() =>\n      ctx.selection.value\n        .map((id) => ctx.annotations.value.find((a) => a.id === id))\n        .filter((a): a is Annotation => !!a)\n    ),\n    byPage: (page: number) => ctx.annotations.value.filter((a) => a.page === page),\n    add: (input: AnnotationInput) => store()?.add(input),\n    update: (id: string, patch: Partial<Annotation>) => store()?.update(id, patch),\n    remove: (id: string) => store()?.remove(id) ?? false,\n    select: (ids: string[]) => store()?.select(ids),\n    /** Replies in creation order for a note id. */\n    replies: (id: string) => repliesTo(ctx.annotations.value, id),\n    /** Keeps a suggested redaction as the user's own, in the default redaction colour. */\n    accept: (id: string) => {\n      const s = store()\n      return s ? acceptSuggestion(s, id) : undefined\n    },\n    dismiss: (id: string) => store()?.remove(id) ?? false,\n  }\n}\n"],"mappings":";;;;AAOA,SAAgBA,IAAiB;CAC/B,IAAMC,IAAMC,EAAc,kBAAkB,GACtCC,UAAcF,EAAI,SAAS,OAAO;CACxC,OAAO;EACL,aAAaA,EAAI;EACjB,WAAWA,EAAI;EACf,UAAUG,QACRH,EAAI,UAAU,MACX,KAAK,MAAOA,EAAI,YAAY,MAAM,MAAM,MAAMI,EAAE,OAAOC,CAAE,CAAC,CAAC,CAC3D,QAAQ,MAAuB,CAAC,CAACD,CAAC,CACvC;EACA,SAAS,MAAiBJ,EAAI,YAAY,MAAM,QAAQ,MAAMI,EAAE,SAASE,CAAI;EAC7E,MAAM,MAA2BJ,EAAM,CAAC,EAAE,IAAIK,CAAK;EACnD,SAAS,GAAY,MAA+BL,EAAM,CAAC,EAAE,OAAOG,GAAIG,CAAK;EAC7E,SAAS,MAAeN,EAAM,CAAC,EAAE,OAAOG,CAAE,KAAK;EAC/C,SAAS,MAAkBH,EAAM,CAAC,EAAE,OAAOO,CAAG;EAE9C,UAAU,MAAeC,EAAUV,EAAI,YAAY,OAAOK,CAAE;EAE5D,SAAS,MAAe;GACtB,IAAMM,IAAIT,EAAM;GAChB,OAAOS,IAAIC,EAAiBD,GAAGN,CAAE,IAAI,KAAA;EACvC;EACA,UAAU,MAAeH,EAAM,CAAC,EAAE,OAAOG,CAAE,KAAK;CAClD;AACF"}

package/dist/composables/useDocument.d.ts

@@ -0,0 +1,12 @@
+import { AnnotationDocument, ImportOptions } from '@inkbar/core';
+export declare function useDocument(): {
+    document: Readonly<import('vue').ShallowRef<import('@inkbar/core').InkDocument | null>>;
+    status: Readonly<import('vue').Ref<import('@inkbar/core').InkStatus, import('@inkbar/core').InkStatus>>;
+    isReady: import('vue').ComputedRef<boolean>;
+    error: import('vue').ComputedRef<import('@inkbar/core').InkError | null>;
+    pages: import('vue').ComputedRef<readonly import('@inkbar/core').PageInfo[]>;
+    info: import('vue').ComputedRef<import('@inkbar/core').DocumentInfo | null>;
+    exportAnnotations: () => AnnotationDocument | undefined;
+    importAnnotations: (data: AnnotationDocument | string, opts?: ImportOptions) => import('@inkbar/core').ImportResult | undefined;
+};
+//# sourceMappingURL=useDocument.d.ts.map

package/dist/composables/useDocument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDocument.d.ts","sourceRoot":"","sources":["../../src/composables/useDocument.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAErE,wBAAgB,WAAW;;;;;;;;8BAYG,kBAAkB,GAAG,MAAM,SAAS,aAAa;EAG9E"}

package/dist/composables/useDocument.js

@@ -0,0 +1,20 @@
+import { useInkContext as e } from "../context.js";
+import { computed as t } from "vue";
+//#region src/composables/useDocument.ts
+function n() {
+	let n = e("useDocument()");
+	return {
+		document: n.document,
+		status: n.status,
+		isReady: t(() => n.status.value.state === "ready"),
+		error: t(() => n.status.value.state === "error" ? n.status.value.error : null),
+		pages: t(() => n.document.value?.pages ?? []),
+		info: t(() => n.document.value?.info ?? null),
+		exportAnnotations: () => n.document.value?.exportAnnotations("json"),
+		importAnnotations: (e, t) => n.document.value?.importAnnotations(e, t)
+	};
+}
+//#endregion
+export { n as useDocument };
+
+//# sourceMappingURL=useDocument.js.map

package/dist/composables/useDocument.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDocument.js","names":["useDocument","ctx","useInkContext","computed","data","opts"],"sources":["../../src/composables/useDocument.ts"],"sourcesContent":["import { computed } from 'vue'\n\nimport { useInkContext } from '../context'\n\nimport type { AnnotationDocument, ImportOptions } from '@inkbar/core'\n\nexport function useDocument() {\n  const ctx = useInkContext('useDocument()')\n  return {\n    document: ctx.document,\n    status: ctx.status,\n    isReady: computed(() => ctx.status.value.state === 'ready'),\n    error: computed(() =>\n      ctx.status.value.state === 'error' ? ctx.status.value.error : null\n    ),\n    pages: computed(() => ctx.document.value?.pages ?? []),\n    info: computed(() => ctx.document.value?.info ?? null),\n    exportAnnotations: () => ctx.document.value?.exportAnnotations('json'),\n    importAnnotations: (data: AnnotationDocument | string, opts?: ImportOptions) =>\n      ctx.document.value?.importAnnotations(data, opts),\n  }\n}\n"],"mappings":";;;AAMA,SAAgBA,IAAc;CAC5B,IAAMC,IAAMC,EAAc,eAAe;CACzC,OAAO;EACL,UAAUD,EAAI;EACd,QAAQA,EAAI;EACZ,SAASE,QAAeF,EAAI,OAAO,MAAM,UAAU,OAAO;EAC1D,OAAOE,QACLF,EAAI,OAAO,MAAM,UAAU,UAAUA,EAAI,OAAO,MAAM,QAAQ,IAChE;EACA,OAAOE,QAAeF,EAAI,SAAS,OAAO,SAAS,CAAC,CAAC;EACrD,MAAME,QAAeF,EAAI,SAAS,OAAO,QAAQ,IAAI;EACrD,yBAAyBA,EAAI,SAAS,OAAO,kBAAkB,MAAM;EACrE,oBAAoB,GAAmC,MACrDA,EAAI,SAAS,OAAO,kBAAkBG,GAAMC,CAAI;CACpD;AACF"}

package/dist/composables/useEmbedded.d.ts

@@ -0,0 +1,6 @@
+export declare function useEmbedded(): {
+    summary: import('vue').ComputedRef<readonly import('@inkbar/core').EmbeddedSummary[]>;
+    total: import('vue').ComputedRef<number>;
+    hasAny: import('vue').ComputedRef<boolean>;
+};
+//# sourceMappingURL=useEmbedded.d.ts.map

package/dist/composables/useEmbedded.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEmbedded.d.ts","sourceRoot":"","sources":["../../src/composables/useEmbedded.ts"],"names":[],"mappings":"AAIA,wBAAgB,WAAW;;;;EAQ1B"}

package/dist/composables/useEmbedded.js

@@ -0,0 +1,15 @@
+import { useInkContext as e } from "../context.js";
+import { computed as t } from "vue";
+//#region src/composables/useEmbedded.ts
+function n() {
+	let n = e("useEmbedded()"), r = t(() => n.document.value?.embedded ?? []);
+	return {
+		summary: r,
+		total: t(() => r.value.reduce((e, t) => e + t.count, 0)),
+		hasAny: t(() => r.value.length > 0)
+	};
+}
+//#endregion
+export { n as useEmbedded };
+
+//# sourceMappingURL=useEmbedded.js.map

package/dist/composables/useEmbedded.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEmbedded.js","names":["useEmbedded","ctx","useInkContext","summary","computed","n","s"],"sources":["../../src/composables/useEmbedded.ts"],"sourcesContent":["import { computed } from 'vue'\n\nimport { useInkContext } from '../context'\n\nexport function useEmbedded() {\n  const ctx = useInkContext('useEmbedded()')\n  const summary = computed(() => ctx.document.value?.embedded ?? [])\n  return {\n    summary,\n    total: computed(() => summary.value.reduce((n, s) => n + s.count, 0)),\n    hasAny: computed(() => summary.value.length > 0),\n  }\n}\n"],"mappings":";;;AAIA,SAAgBA,IAAc;CAC5B,IAAMC,IAAMC,EAAc,eAAe,GACnCC,IAAUC,QAAeH,EAAI,SAAS,OAAO,YAAY,CAAC,CAAC;CACjE,OAAO;EACL;EACA,OAAOG,QAAeD,EAAQ,MAAM,QAAQ,GAAG,MAAME,IAAIC,EAAE,OAAO,CAAC,CAAC;EACpE,QAAQF,QAAeD,EAAQ,MAAM,SAAS,CAAC;CACjD;AACF"}

package/dist/composables/useHistory.d.ts

@@ -0,0 +1,7 @@
+import { InkHistory } from '../context';
+/**
+ * Undo and redo. Uncontrolled documents use the core history; controlled hosts that pass
+ * `history` to InkRoot get a snapshot stack over their own list, applied through v-model.
+ */
+export declare function useHistory(): InkHistory;
+//# sourceMappingURL=useHistory.d.ts.map

package/dist/composables/useHistory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useHistory.d.ts","sourceRoot":"","sources":["../../src/composables/useHistory.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAE5C;;;GAGG;AACH,wBAAgB,UAAU,IAAI,UAAU,CAEvC"}

package/dist/composables/useHistory.js

@@ -0,0 +1,9 @@
+import { useInkContext as e } from "../context.js";
+//#region src/composables/useHistory.ts
+function t() {
+	return e("useHistory()").history;
+}
+//#endregion
+export { t as useHistory };
+
+//# sourceMappingURL=useHistory.js.map

package/dist/composables/useHistory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useHistory.js","names":["useHistory","useInkContext"],"sources":["../../src/composables/useHistory.ts"],"sourcesContent":["import { useInkContext } from '../context'\n\nimport type { InkHistory } from '../context'\n\n/**\n * Undo and redo. Uncontrolled documents use the core history; controlled hosts that pass\n * `history` to InkRoot get a snapshot stack over their own list, applied through v-model.\n */\nexport function useHistory(): InkHistory {\n  return useInkContext('useHistory()').history\n}\n"],"mappings":";;AAQA,SAAgBA,IAAyB;CACvC,OAAOC,EAAc,cAAc,CAAC,CAAC;AACvC"}

package/dist/composables/usePage.d.ts

@@ -0,0 +1,10 @@
+export declare function usePage(): {
+    /** 0-based. */
+    current: Readonly<import('vue').Ref<number, number>>;
+    count: import('vue').ComputedRef<number>;
+    goTo: (index: number) => void | undefined;
+    next: () => void | undefined;
+    previous: () => void | undefined;
+    scrollToAnnotation(id: string): void;
+};
+//# sourceMappingURL=usePage.d.ts.map

package/dist/composables/usePage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePage.d.ts","sourceRoot":"","sources":["../../src/composables/usePage.ts"],"names":[],"mappings":"AAKA,wBAAgB,OAAO;IAInB,eAAe;;;kBAGD,MAAM;;;2BAGG,MAAM;EAKhC"}

package/dist/composables/usePage.js

@@ -0,0 +1,22 @@
+import { useInkContext as e } from "../context.js";
+import { useReadable as t } from "../use-readable.js";
+import { computed as n } from "vue";
+//#region src/composables/usePage.ts
+function r() {
+	let r = e("usePage()"), i = t(() => r.viewport.value?.currentPage ?? null, 0);
+	return {
+		current: i,
+		count: n(() => r.document.value?.pages.length ?? 0),
+		goTo: (e) => r.viewport.value?.scrollToPage(e),
+		next: () => r.viewport.value?.scrollToPage(i.value + 1),
+		previous: () => r.viewport.value?.scrollToPage(i.value - 1),
+		scrollToAnnotation(e) {
+			let t = r.document.value?.annotations.get(e);
+			t && r.viewport.value?.scrollToRect(t.page, t.rect);
+		}
+	};
+}
+//#endregion
+export { r as usePage };
+
+//# sourceMappingURL=usePage.js.map

package/dist/composables/usePage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePage.js","names":["usePage","ctx","useInkContext","current","useReadable","computed","index","a","id"],"sources":["../../src/composables/usePage.ts"],"sourcesContent":["import { computed } from 'vue'\n\nimport { useInkContext } from '../context'\nimport { useReadable } from '../use-readable'\n\nexport function usePage() {\n  const ctx = useInkContext('usePage()')\n  const current = useReadable<number>(() => ctx.viewport.value?.currentPage ?? null, 0)\n  return {\n    /** 0-based. */\n    current,\n    count: computed(() => ctx.document.value?.pages.length ?? 0),\n    goTo: (index: number) => ctx.viewport.value?.scrollToPage(index),\n    next: () => ctx.viewport.value?.scrollToPage(current.value + 1),\n    previous: () => ctx.viewport.value?.scrollToPage(current.value - 1),\n    scrollToAnnotation(id: string) {\n      const a = ctx.document.value?.annotations.get(id)\n      if (a) ctx.viewport.value?.scrollToRect(a.page, a.rect)\n    },\n  }\n}\n"],"mappings":";;;;AAKA,SAAgBA,IAAU;CACxB,IAAMC,IAAMC,EAAc,WAAW,GAC/BC,IAAUC,QAA0BH,EAAI,SAAS,OAAO,eAAe,MAAM,CAAC;CACpF,OAAO;EAEL;EACA,OAAOI,QAAeJ,EAAI,SAAS,OAAO,MAAM,UAAU,CAAC;EAC3D,OAAO,MAAkBA,EAAI,SAAS,OAAO,aAAaK,CAAK;EAC/D,YAAYL,EAAI,SAAS,OAAO,aAAaE,EAAQ,QAAQ,CAAC;EAC9D,gBAAgBF,EAAI,SAAS,OAAO,aAAaE,EAAQ,QAAQ,CAAC;EAClE,mBAAmB,GAAY;GAC7B,IAAMI,IAAIN,EAAI,SAAS,OAAO,YAAY,IAAIO,CAAE;GAChD,AAAID,KAAGN,EAAI,SAAS,OAAO,aAAaM,EAAE,MAAMA,EAAE,IAAI;EACxD;CACF;AACF"}

package/dist/composables/useSelection.d.ts

@@ -0,0 +1,6 @@
+export declare function useSelection(): {
+    selection: Readonly<import('vue').Ref<readonly string[], readonly string[]>>;
+    select: (ids: string[]) => void | undefined;
+    clear: () => void | undefined;
+};
+//# sourceMappingURL=useSelection.d.ts.map

package/dist/composables/useSelection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSelection.d.ts","sourceRoot":"","sources":["../../src/composables/useSelection.ts"],"names":[],"mappings":"AAEA,wBAAgB,YAAY;;kBAIV,MAAM,EAAE;;EAGzB"}

package/dist/composables/useSelection.js

@@ -0,0 +1,14 @@
+import { useInkContext as e } from "../context.js";
+//#region src/composables/useSelection.ts
+function t() {
+	let t = e("useSelection()");
+	return {
+		selection: t.selection,
+		select: (e) => t.document.value?.annotations.select(e),
+		clear: () => t.document.value?.annotations.select([])
+	};
+}
+//#endregion
+export { t as useSelection };
+
+//# sourceMappingURL=useSelection.js.map

package/dist/composables/useSelection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSelection.js","names":["useSelection","ctx","useInkContext","ids"],"sources":["../../src/composables/useSelection.ts"],"sourcesContent":["import { useInkContext } from '../context'\n\nexport function useSelection() {\n  const ctx = useInkContext('useSelection()')\n  return {\n    selection: ctx.selection,\n    select: (ids: string[]) => ctx.document.value?.annotations.select(ids),\n    clear: () => ctx.document.value?.annotations.select([]),\n  }\n}\n"],"mappings":";;AAEA,SAAgBA,IAAe;CAC7B,IAAMC,IAAMC,EAAc,gBAAgB;CAC1C,OAAO;EACL,WAAWD,EAAI;EACf,SAAS,MAAkBA,EAAI,SAAS,OAAO,YAAY,OAAOE,CAAG;EACrE,aAAaF,EAAI,SAAS,OAAO,YAAY,OAAO,CAAC,CAAC;CACxD;AACF"}

package/dist/composables/useTool.d.ts

@@ -0,0 +1,6 @@
+import { ToolId } from '@inkbar/core/dom';
+export declare function useTool(): {
+    tool: Readonly<import('vue').Ref<ToolId, ToolId>>;
+    setTool: (id: ToolId) => void;
+};
+//# sourceMappingURL=useTool.d.ts.map

package/dist/composables/useTool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTool.d.ts","sourceRoot":"","sources":["../../src/composables/useTool.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAE9C,wBAAgB,OAAO;;kBAEkB,MAAM;EAC9C"}

package/dist/composables/useTool.js

@@ -0,0 +1,13 @@
+import { useInkContext as e } from "../context.js";
+//#region src/composables/useTool.ts
+function t() {
+	let t = e("useTool()");
+	return {
+		tool: t.tool,
+		setTool: (e) => t.setTool(e)
+	};
+}
+//#endregion
+export { t as useTool };
+
+//# sourceMappingURL=useTool.js.map

package/dist/composables/useTool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTool.js","names":["useTool","ctx","useInkContext","id"],"sources":["../../src/composables/useTool.ts"],"sourcesContent":["import { useInkContext } from '../context'\n\nimport type { ToolId } from '@inkbar/core/dom'\n\nexport function useTool() {\n  const ctx = useInkContext('useTool()')\n  return { tool: ctx.tool, setTool: (id: ToolId) => ctx.setTool(id) }\n}\n"],"mappings":";;AAIA,SAAgBA,IAAU;CACxB,IAAMC,IAAMC,EAAc,WAAW;CACrC,OAAO;EAAE,MAAMD,EAAI;EAAM,UAAU,MAAeA,EAAI,QAAQE,CAAE;CAAE;AACpE"}

package/dist/composables/useZoom.d.ts

@@ -0,0 +1,9 @@
+import { ZoomValue } from '@inkbar/core/dom';
+export declare function useZoom(): {
+    zoom: Readonly<import('vue').Ref<ZoomValue, ZoomValue>>;
+    scale: Readonly<import('vue').Ref<number, number>>;
+    setZoom: (z: ZoomValue) => void | undefined;
+    zoomIn: () => void | undefined;
+    zoomOut: () => void | undefined;
+};
+//# sourceMappingURL=useZoom.d.ts.map

package/dist/composables/useZoom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useZoom.d.ts","sourceRoot":"","sources":["../../src/composables/useZoom.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAEjD,wBAAgB,OAAO;;;iBAON,SAAS;;;EAIzB"}

package/dist/composables/useZoom.js

@@ -0,0 +1,17 @@
+import { useInkContext as e } from "../context.js";
+import { useReadable as t } from "../use-readable.js";
+//#region src/composables/useZoom.ts
+function n() {
+	let n = e("useZoom()");
+	return {
+		zoom: t(() => n.viewport.value?.zoom ?? null, "fit-width"),
+		scale: t(() => n.viewport.value?.scale ?? null, 1),
+		setZoom: (e) => n.viewport.value?.setZoom(e),
+		zoomIn: () => n.viewport.value?.zoomBy(1.25),
+		zoomOut: () => n.viewport.value?.zoomBy(.8)
+	};
+}
+//#endregion
+export { n as useZoom };
+
+//# sourceMappingURL=useZoom.js.map

package/dist/composables/useZoom.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useZoom.js","names":["useZoom","ctx","useInkContext","useReadable","z"],"sources":["../../src/composables/useZoom.ts"],"sourcesContent":["import { useInkContext } from '../context'\nimport { useReadable } from '../use-readable'\n\nimport type { ZoomValue } from '@inkbar/core/dom'\n\nexport function useZoom() {\n  const ctx = useInkContext('useZoom()')\n  const zoom = useReadable<ZoomValue>(() => ctx.viewport.value?.zoom ?? null, 'fit-width')\n  const scale = useReadable<number>(() => ctx.viewport.value?.scale ?? null, 1)\n  return {\n    zoom,\n    scale,\n    setZoom: (z: ZoomValue) => ctx.viewport.value?.setZoom(z),\n    zoomIn: () => ctx.viewport.value?.zoomBy(1.25),\n    zoomOut: () => ctx.viewport.value?.zoomBy(0.8),\n  }\n}\n"],"mappings":";;;AAKA,SAAgBA,IAAU;CACxB,IAAMC,IAAMC,EAAc,WAAW;CAGrC,OAAO;EACL,MAHWC,QAA6BF,EAAI,SAAS,OAAO,QAAQ,MAAM,WAG1E;EACA,OAHYE,QAA0BF,EAAI,SAAS,OAAO,SAAS,MAAM,CAGzE;EACA,UAAU,MAAiBA,EAAI,SAAS,OAAO,QAAQG,CAAC;EACxD,cAAcH,EAAI,SAAS,OAAO,OAAO,IAAI;EAC7C,eAAeA,EAAI,SAAS,OAAO,OAAO,EAAG;CAC/C;AACF"}

package/dist/context.d.ts

@@ -0,0 +1,50 @@
+import { Annotation, InkDocument, InkStatus, PdfAssets } from '@inkbar/core';
+import { ToolController, ToolId, Viewport, ZoomValue } from '@inkbar/core/dom';
+import { Ref, ShallowRef } from 'vue';
+export type { InkStatus };
+/** Undo and redo for the current document, whichever mode its annotations are in. */
+export interface InkHistory {
+    canUndo: Readonly<Ref<boolean>>;
+    canRedo: Readonly<Ref<boolean>>;
+    undo: () => void;
+    redo: () => void;
+    clear: () => void;
+    /**
+     * Runs `fn` and records what it changes as one undo step. The host still receives one change
+     * per add. Controlled, the history groups the resulting list changes into one step, and
+     * `canUndo` updates once the current task ends. Any other change the host applies in that
+     * same window joins the step.
+     */
+    batch: (fn: () => void) => void;
+}
+export interface InkContext {
+    assets: Readonly<Ref<PdfAssets>>;
+    document: Readonly<ShallowRef<InkDocument | null>>;
+    /** `loading` from the moment a document starts opening, then the document's own status. */
+    status: Readonly<Ref<InkStatus>>;
+    annotations: Readonly<Ref<readonly Annotation[]>>;
+    selection: Readonly<Ref<readonly string[]>>;
+    /** Set by InkViewport once it has mounted its viewport and tool controller. */
+    viewport: ShallowRef<Viewport | null>;
+    tools: ShallowRef<ToolController | null>;
+    /** Desired tool; InkViewport applies it to the controller. */
+    tool: Readonly<Ref<ToolId>>;
+    setTool(id: ToolId): void;
+    /** Desired zoom and page from the host's v-models; InkViewport applies and reports back. */
+    zoomModel: Readonly<Ref<ZoomValue | undefined>>;
+    pageModel: Readonly<Ref<number | undefined>>;
+    reportZoom(z: ZoomValue): void;
+    reportPage(p: number): void;
+    /** Last activated annotation (Enter, click with the note tool, etc.). Popovers key off this. */
+    activated: Readonly<Ref<string | null>>;
+    setActivated(id: string | null): void;
+    history: InkHistory;
+    rootEl: Readonly<Ref<HTMLElement | null>>;
+}
+export declare const injectInkContext: <T extends InkContext | null | undefined = InkContext>(fallback?: T | undefined) => T extends null ? InkContext | null : InkContext, provideInkContext: (contextValue: InkContext) => InkContext;
+/**
+ * The context for composables: throws a readable error when called outside a component
+ * rendered inside `InkRoot`, instead of Vue's injection warning.
+ */
+export declare function useInkContext(consumer: string): InkContext;
+//# sourceMappingURL=context.d.ts.map

package/dist/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AACjF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AACnF,OAAO,KAAK,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,KAAK,CAAA;AAE1C,YAAY,EAAE,SAAS,EAAE,CAAA;AAEzB,qFAAqF;AACrF,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAA;IAC/B,OAAO,EAAE,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAA;IAC/B,IAAI,EAAE,MAAM,IAAI,CAAA;IAChB,IAAI,EAAE,MAAM,IAAI,CAAA;IAChB,KAAK,EAAE,MAAM,IAAI,CAAA;IACjB;;;;;OAKG;IACH,KAAK,EAAE,CAAC,EAAE,EAAE,MAAM,IAAI,KAAK,IAAI,CAAA;CAChC;AAED,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAA;IAChC,QAAQ,EAAE,QAAQ,CAAC,UAAU,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC,CAAA;IAClD,2FAA2F;IAC3F,MAAM,EAAE,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAA;IAChC,WAAW,EAAE,QAAQ,CAAC,GAAG,CAAC,SAAS,UAAU,EAAE,CAAC,CAAC,CAAA;IACjD,SAAS,EAAE,QAAQ,CAAC,GAAG,CAAC,SAAS,MAAM,EAAE,CAAC,CAAC,CAAA;IAC3C,+EAA+E;IAC/E,QAAQ,EAAE,UAAU,CAAC,QAAQ,GAAG,IAAI,CAAC,CAAA;IACrC,KAAK,EAAE,UAAU,CAAC,cAAc,GAAG,IAAI,CAAC,CAAA;IACxC,8DAA8D;IAC9D,IAAI,EAAE,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAA;IAC3B,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,4FAA4F;IAC5F,SAAS,EAAE,QAAQ,CAAC,GAAG,CAAC,SAAS,GAAG,SAAS,CAAC,CAAC,CAAA;IAC/C,SAAS,EAAE,QAAQ,CAAC,GAAG,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC,CAAA;IAC5C,UAAU,CAAC,CAAC,EAAE,SAAS,GAAG,IAAI,CAAA;IAC9B,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,gGAAgG;IAChG,SAAS,EAAE,QAAQ,CAAC,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC,CAAA;IACvC,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAAA;IACrC,OAAO,EAAE,UAAU,CAAA;IACnB,MAAM,EAAE,QAAQ,CAAC,GAAG,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC,CAAA;CAC1C;AAED,eAAO,MAAO,gBAAgB,uIAAE,iBAAiB,0CAAwC,CAAA;AAEzF;;;GAGG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,CAO1D"}

package/dist/context.js

@@ -0,0 +1,13 @@
+import { getCurrentInstance as e } from "vue";
+import { createContext as t } from "reka-ui";
+//#region src/context.ts
+var [n, r] = t("InkRoot");
+function i(t) {
+	let r = e() ? n(null) : null;
+	if (!r) throw Error(`[inkbar] ${t} must be called in a component inside <InkRoot>.`);
+	return r;
+}
+//#endregion
+export { n as injectInkContext, r as provideInkContext, i as useInkContext };
+
+//# sourceMappingURL=context.js.map

package/dist/context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.js","names":["injectInkContext","provideInkContext","createContext","useInkContext","ctx","getCurrentInstance","consumer"],"sources":["../src/context.ts"],"sourcesContent":["import { createContext } from 'reka-ui'\nimport { getCurrentInstance } from 'vue'\n\nimport type { Annotation, InkDocument, InkStatus, PdfAssets } from '@inkbar/core'\nimport type { ToolController, ToolId, Viewport, ZoomValue } from '@inkbar/core/dom'\nimport type { Ref, ShallowRef } from 'vue'\n\nexport type { InkStatus }\n\n/** Undo and redo for the current document, whichever mode its annotations are in. */\nexport interface InkHistory {\n  canUndo: Readonly<Ref<boolean>>\n  canRedo: Readonly<Ref<boolean>>\n  undo: () => void\n  redo: () => void\n  clear: () => void\n  /**\n   * Runs `fn` and records what it changes as one undo step. The host still receives one change\n   * per add. Controlled, the history groups the resulting list changes into one step, and\n   * `canUndo` updates once the current task ends. Any other change the host applies in that\n   * same window joins the step.\n   */\n  batch: (fn: () => void) => void\n}\n\nexport interface InkContext {\n  assets: Readonly<Ref<PdfAssets>>\n  document: Readonly<ShallowRef<InkDocument | null>>\n  /** `loading` from the moment a document starts opening, then the document's own status. */\n  status: Readonly<Ref<InkStatus>>\n  annotations: Readonly<Ref<readonly Annotation[]>>\n  selection: Readonly<Ref<readonly string[]>>\n  /** Set by InkViewport once it has mounted its viewport and tool controller. */\n  viewport: ShallowRef<Viewport | null>\n  tools: ShallowRef<ToolController | null>\n  /** Desired tool; InkViewport applies it to the controller. */\n  tool: Readonly<Ref<ToolId>>\n  setTool(id: ToolId): void\n  /** Desired zoom and page from the host's v-models; InkViewport applies and reports back. */\n  zoomModel: Readonly<Ref<ZoomValue | undefined>>\n  pageModel: Readonly<Ref<number | undefined>>\n  reportZoom(z: ZoomValue): void\n  reportPage(p: number): void\n  /** Last activated annotation (Enter, click with the note tool, etc.). Popovers key off this. */\n  activated: Readonly<Ref<string | null>>\n  setActivated(id: string | null): void\n  history: InkHistory\n  rootEl: Readonly<Ref<HTMLElement | null>>\n}\n\nexport const [injectInkContext, provideInkContext] = createContext<InkContext>('InkRoot')\n\n/**\n * The context for composables: throws a readable error when called outside a component\n * rendered inside `InkRoot`, instead of Vue's injection warning.\n */\nexport function useInkContext(consumer: string): InkContext {\n  const ctx = getCurrentInstance() ? injectInkContext(null) : null\n  if (!ctx)\n    throw new Error(\n      `[inkbar] ${consumer} must be called in a component inside <InkRoot>.`\n    )\n  return ctx\n}\n"],"mappings":";;;AAkDA,IAAa,CAACA,GAAkBC,KAAqBC,EAA0B,SAAS;AAMxF,SAAgBC,EAAc,GAA8B;CAC1D,IAAMC,IAAMC,EAAmB,IAAIL,EAAiB,IAAI,IAAI;CAC5D,IAAI,CAACI,GACH,MAAU,MACR,YAAYE,EAAS,iDACvB;CACF,OAAOF;AACT"}

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+export { default as InkRoot } from './components/InkRoot.vue';
+export { injectInkContext } from './context';
+export type { InkContext, InkHistory, InkStatus } from './context';
+export { useReadable } from './use-readable';
+export { useDocument } from './composables/useDocument';
+export { useAnnotations } from './composables/useAnnotations';
+export { useTool } from './composables/useTool';
+export { useSelection } from './composables/useSelection';
+export { useZoom } from './composables/useZoom';
+export { usePage } from './composables/usePage';
+export { useHistory } from './composables/useHistory';
+export { useEmbedded } from './composables/useEmbedded';
+export { default as InkViewport } from './components/InkViewport.vue';
+export { default as InkPage } from './components/InkPage.vue';
+export { default as InkAnnotation } from './components/InkAnnotation.vue';
+export type { AnnotationSlotProps, AnnotationState } from './components/annotation-slot';
+export { default as InkToolbar } from './components/InkToolbar.vue';
+export { default as InkIcon } from './components/InkIcon.vue';
+export { default as InkToolButton } from './components/InkToolButton.vue';
+export { default as InkToolbarSeparator } from './components/InkToolbarSeparator.vue';
+export { default as InkUndo } from './components/InkUndo.vue';
+export { default as InkRedo } from './components/InkRedo.vue';
+export { default as InkZoomIn } from './components/InkZoomIn.vue';
+export { default as InkZoomOut } from './components/InkZoomOut.vue';
+export { default as InkZoomSelect } from './components/InkZoomSelect.vue';
+export { default as InkPageInput } from './components/InkPageInput.vue';
+export { default as InkPageCount } from './components/InkPageCount.vue';
+export { default as InkPrevPage } from './components/InkPrevPage.vue';
+export { default as InkNextPage } from './components/InkNextPage.vue';
+export { default as InkNotePopover } from './components/InkNotePopover.vue';
+export type { NotePopoverSlotProps } from './components/InkNotePopover.vue';
+export { default as InkSuggestionCard } from './components/InkSuggestionCard.vue';
+export type { ConfidenceBucket, SuggestionCardSlotProps, } from './components/InkSuggestionCard.vue';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,0BAA0B,CAAA;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAA;AAC5C,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAClE,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAC5C,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAA;AAC7D,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAA;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AACzD,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAA;AAC/C,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAA;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AACrD,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AACvD,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,8BAA8B,CAAA;AACrE,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,0BAA0B,CAAA;AAC7D,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,gCAAgC,CAAA;AACzE,YAAY,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAA;AACxF,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,6BAA6B,CAAA;AACnE,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,0BAA0B,CAAA;AAC7D,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,gCAAgC,CAAA;AACzE,OAAO,EAAE,OAAO,IAAI,mBAAmB,EAAE,MAAM,sCAAsC,CAAA;AACrF,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,0BAA0B,CAAA;AAC7D,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,0BAA0B,CAAA;AAC7D,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,4BAA4B,CAAA;AACjE,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,6BAA6B,CAAA;AACnE,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,gCAAgC,CAAA;AACzE,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,+BAA+B,CAAA;AACvE,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,+BAA+B,CAAA;AACvE,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,8BAA8B,CAAA;AACrE,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,8BAA8B,CAAA;AACrE,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,iCAAiC,CAAA;AAC3E,YAAY,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAA;AAC3E,OAAO,EAAE,OAAO,IAAI,iBAAiB,EAAE,MAAM,oCAAoC,CAAA;AACjF,YAAY,EACV,gBAAgB,EAChB,uBAAuB,GACxB,MAAM,oCAAoC,CAAA"}

package/dist/index.js

@@ -0,0 +1,30 @@
+import { injectInkContext as e } from "./context.js";
+import { useReadable as t } from "./use-readable.js";
+import n from "./components/InkRoot.js";
+import { useDocument as r } from "./composables/useDocument.js";
+import { useAnnotations as i } from "./composables/useAnnotations.js";
+import { useTool as a } from "./composables/useTool.js";
+import { useSelection as o } from "./composables/useSelection.js";
+import { useZoom as s } from "./composables/useZoom.js";
+import { usePage as c } from "./composables/usePage.js";
+import { useHistory as l } from "./composables/useHistory.js";
+import { useEmbedded as u } from "./composables/useEmbedded.js";
+import d from "./components/InkAnnotation.js";
+import f from "./components/InkPage.js";
+import p from "./components/InkViewport.js";
+import m from "./components/InkToolbar.js";
+import h from "./components/InkIcon.js";
+import g from "./components/InkToolButton.js";
+import _ from "./components/InkToolbarSeparator.js";
+import v from "./components/InkUndo.js";
+import y from "./components/InkRedo.js";
+import b from "./components/InkZoomIn.js";
+import x from "./components/InkZoomOut.js";
+import S from "./components/InkZoomSelect.js";
+import C from "./components/InkPageInput.js";
+import w from "./components/InkPageCount.js";
+import T from "./components/InkPrevPage.js";
+import E from "./components/InkNextPage.js";
+import D from "./components/InkNotePopover.js";
+import O from "./components/InkSuggestionCard.js";
+export { d as InkAnnotation, h as InkIcon, E as InkNextPage, D as InkNotePopover, f as InkPage, w as InkPageCount, C as InkPageInput, T as InkPrevPage, y as InkRedo, n as InkRoot, O as InkSuggestionCard, g as InkToolButton, m as InkToolbar, _ as InkToolbarSeparator, v as InkUndo, p as InkViewport, b as InkZoomIn, x as InkZoomOut, S as InkZoomSelect, e as injectInkContext, i as useAnnotations, r as useDocument, u as useEmbedded, l as useHistory, c as usePage, t as useReadable, o as useSelection, a as useTool, s as useZoom };

package/dist/ref-history.d.ts

@@ -0,0 +1,18 @@
+import { Ref } from 'vue';
+import { InkHistory } from './context';
+import { Annotation } from '@inkbar/core';
+export interface RefHistoryOptions {
+    /** The host's list (the `annotations` v-model). Undefined when the host does not control it. */
+    source: () => readonly Annotation[] | undefined;
+    /** Proposes a list to the host; the step only counts once the host applies it. */
+    apply: (list: Annotation[]) => void;
+    enabled: Readonly<Ref<boolean>>;
+    limit?: number;
+}
+/**
+ * Snapshot undo and redo over a host-owned annotation list, for controlled hosts. The stacks
+ * live in core's `createSnapshotHistory`; this wrapper feeds it from a watch on the host's list
+ * and exposes refs.
+ */
+export declare function createRefHistory(opts: RefHistoryOptions): InkHistory;
+//# sourceMappingURL=ref-history.d.ts.map

package/dist/ref-history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ref-history.d.ts","sourceRoot":"","sources":["../src/ref-history.ts"],"names":[],"mappings":"AACA,OAAO,EAAmB,KAAK,GAAG,EAAE,MAAM,KAAK,CAAA;AAI/C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAC3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAE9C,MAAM,WAAW,iBAAiB;IAChC,gGAAgG;IAChG,MAAM,EAAE,MAAM,SAAS,UAAU,EAAE,GAAG,SAAS,CAAA;IAC/C,kFAAkF;IAClF,KAAK,EAAE,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,IAAI,CAAA;IACnC,OAAO,EAAE,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAA;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,iBAAiB,GAAG,UAAU,CAmBpE"}

package/dist/ref-history.js

@@ -0,0 +1,25 @@
+import { useReadable as e } from "./use-readable.js";
+import { computed as t, watch as n } from "vue";
+import { createSnapshotHistory as r } from "@inkbar/core";
+//#region src/ref-history.ts
+function i(i) {
+	let a = r({
+		apply: i.apply,
+		enabled: () => i.enabled.value,
+		...i.limit === void 0 ? {} : { limit: i.limit }
+	});
+	a.observe(i.source()), n(i.source, (e) => a.observe(e));
+	let o = e(a.canUndo, !1), s = e(a.canRedo, !1);
+	return {
+		canUndo: t(() => i.enabled.value && o.value),
+		canRedo: t(() => i.enabled.value && s.value),
+		undo: () => a.undo(),
+		redo: () => a.redo(),
+		clear: () => a.clear(),
+		batch: (e) => a.batch(e)
+	};
+}
+//#endregion
+export { i as createRefHistory };
+
+//# sourceMappingURL=ref-history.js.map

package/dist/ref-history.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ref-history.js","names":["createRefHistory","history","createSnapshotHistory","opts","watch","next","canUndo","useReadable","canRedo","computed","fn"],"sources":["../src/ref-history.ts"],"sourcesContent":["import { createSnapshotHistory } from '@inkbar/core'\nimport { computed, watch, type Ref } from 'vue'\n\nimport { useReadable } from './use-readable'\n\nimport type { InkHistory } from './context'\nimport type { Annotation } from '@inkbar/core'\n\nexport interface RefHistoryOptions {\n  /** The host's list (the `annotations` v-model). Undefined when the host does not control it. */\n  source: () => readonly Annotation[] | undefined\n  /** Proposes a list to the host; the step only counts once the host applies it. */\n  apply: (list: Annotation[]) => void\n  enabled: Readonly<Ref<boolean>>\n  limit?: number\n}\n\n/**\n * Snapshot undo and redo over a host-owned annotation list, for controlled hosts. The stacks\n * live in core's `createSnapshotHistory`; this wrapper feeds it from a watch on the host's list\n * and exposes refs.\n */\nexport function createRefHistory(opts: RefHistoryOptions): InkHistory {\n  const history = createSnapshotHistory({\n    apply: opts.apply,\n    enabled: () => opts.enabled.value,\n    ...(opts.limit === undefined ? {} : { limit: opts.limit }),\n  })\n  // Seeds the current list; later changes are steps.\n  history.observe(opts.source())\n  watch(opts.source, (next) => history.observe(next))\n  const canUndo = useReadable(history.canUndo, false)\n  const canRedo = useReadable(history.canRedo, false)\n  return {\n    canUndo: computed(() => opts.enabled.value && canUndo.value),\n    canRedo: computed(() => opts.enabled.value && canRedo.value),\n    undo: () => history.undo(),\n    redo: () => history.redo(),\n    clear: () => history.clear(),\n    batch: (fn) => history.batch(fn),\n  }\n}\n"],"mappings":";;;;AAsBA,SAAgBA,EAAiB,GAAqC;CACpE,IAAMC,IAAUC,EAAsB;EACpC,OAAOC,EAAK;EACZ,eAAeA,EAAK,QAAQ;EAC5B,GAAIA,EAAK,UAAU,KAAA,IAAY,CAAC,IAAI,EAAE,OAAOA,EAAK,MAAM;CAC1D,CAAC;CAGD,AADAF,EAAQ,QAAQE,EAAK,OAAO,CAAC,GAC7BC,EAAMD,EAAK,SAAS,MAASF,EAAQ,QAAQI,CAAI,CAAC;CAClD,IAAMC,IAAUC,EAAYN,EAAQ,SAAS,EAAK,GAC5CO,IAAUD,EAAYN,EAAQ,SAAS,EAAK;CAClD,OAAO;EACL,SAASQ,QAAeN,EAAK,QAAQ,SAASG,EAAQ,KAAK;EAC3D,SAASG,QAAeN,EAAK,QAAQ,SAASK,EAAQ,KAAK;EAC3D,YAAYP,EAAQ,KAAK;EACzB,YAAYA,EAAQ,KAAK;EACzB,aAAaA,EAAQ,MAAM;EAC3B,QAAQ,MAAOA,EAAQ,MAAMS,CAAE;CACjC;AACF"}

package/dist/use-readable.d.ts

@@ -0,0 +1,5 @@
+import { MaybeRefOrGetter, Ref } from 'vue';
+import { Readable } from '@inkbar/core';
+/** Mirrors a core `Readable` into a Vue ref. Re-subscribes when the source changes. */
+export declare function useReadable<T>(source: MaybeRefOrGetter<Readable<T> | null | undefined>, fallback: T): Readonly<Ref<T>>;
+//# sourceMappingURL=use-readable.d.ts.map

package/dist/use-readable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-readable.d.ts","sourceRoot":"","sources":["../src/use-readable.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,gBAAgB,EACrB,KAAK,GAAG,EACT,MAAM,KAAK,CAAA;AAEZ,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAE5C,uFAAuF;AACvF,wBAAgB,WAAW,CAAC,CAAC,EAC3B,MAAM,EAAE,gBAAgB,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC,EACxD,QAAQ,EAAE,CAAC,GACV,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAwBlB"}

package/dist/use-readable.js

@@ -0,0 +1,16 @@
+import { onScopeDispose as e, shallowRef as t, toValue as n, watch as r } from "vue";
+//#region src/use-readable.ts
+function i(i, a) {
+	let o = t(a), s;
+	return r(() => n(i), (e) => {
+		s?.(), s = void 0, e ? (o.value = e.get(), s = e.subscribe((e) => {
+			o.value = e;
+		})) : o.value = a;
+	}, { immediate: !0 }), e(() => {
+		s?.(), s = void 0;
+	}), o;
+}
+//#endregion
+export { i as useReadable };
+
+//# sourceMappingURL=use-readable.js.map

package/dist/use-readable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-readable.js","names":["useReadable","value","shallowRef","fallback","off","watch","toValue","source","s","v","onScopeDispose"],"sources":["../src/use-readable.ts"],"sourcesContent":["import {\n  onScopeDispose,\n  shallowRef,\n  toValue,\n  watch,\n  type MaybeRefOrGetter,\n  type Ref,\n} from 'vue'\n\nimport type { Readable } from '@inkbar/core'\n\n/** Mirrors a core `Readable` into a Vue ref. Re-subscribes when the source changes. */\nexport function useReadable<T>(\n  source: MaybeRefOrGetter<Readable<T> | null | undefined>,\n  fallback: T\n): Readonly<Ref<T>> {\n  const value = shallowRef<T>(fallback)\n  let off: (() => void) | undefined\n  watch(\n    () => toValue(source),\n    (s) => {\n      off?.()\n      off = undefined\n      if (!s) {\n        value.value = fallback\n        return\n      }\n      value.value = s.get()\n      off = s.subscribe((v) => {\n        value.value = v\n      })\n    },\n    { immediate: true }\n  )\n  onScopeDispose(() => {\n    off?.()\n    off = undefined\n  })\n  return value\n}\n"],"mappings":";;AAYA,SAAgBA,EACd,GACA,GACkB;CAClB,IAAMC,IAAQC,EAAcC,CAAQ,GAChCC;CAqBJ,OApBAC,QACQC,EAAQC,CAAM,IACnB,MAAM;EAGL,AAFAH,IAAM,GACN,IAAM,KAAA,GACDI,KAIL,EAAM,QAAQA,EAAE,IAAI,GACpB,IAAMA,EAAE,WAAW,MAAM;GACvB,EAAM,QAAQC;EAChB,CAAC,KANC,EAAM,QAAQN;CAOlB,GACA,EAAE,WAAW,GAAK,CACpB,GACAO,QAAqB;EAEnB,AADAN,IAAM,GACN,IAAM,KAAA;CACR,CAAC,GACMH;AACT"}

package/package.json

@@ -1,6 +1,55 @@
 {
   "name": "@inkbar/vue",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.2.0",
+  "description": "Vue 3 components and composables for Inkbar, the browser PDF viewer and editor.",
+  "license": "MIT",
+  "homepage": "https://inkbar.dev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/inkbar/inkbar.git",
+    "directory": "packages/vue"
+  },
+  "bugs": "https://github.com/inkbar/inkbar/issues",
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@inkbar/icons": "^0.2.0",
+    "reka-ui": "^2.11.0"
+  },
+  "peerDependencies": {
+    "@inkbar/core": "^0.2.0",
+    "vue": "^3.5.0"
+  },
+  "devDependencies": {
+    "@inkbar/core": "0.2.0",
+    "@inkbar/fixtures": "0.0.0",
+    "@inkbar/theme": "0.2.0",
+    "@playwright/experimental-ct-vue": "1.62.1",
+    "@playwright/test": "1.62.1",
+    "@vitejs/plugin-vue": "^6.0.10",
+    "@vue/compiler-dom": "^3.5.43",
+    "vite": "^8.3.4",
+    "vite-plugin-dts": "^5.1.2",
+    "vitest": "^5.0.4",
+    "vue": "^3.5.43",
+    "vue-tsc": "^3.3.13"
+  },
+  "scripts": {
+    "build": "vue-tsc --noEmit -p tsconfig.json && vite build",
+    "typecheck": "vue-tsc --noEmit -p tsconfig.json",
+    "lint": "eslint src playwright",
+    "test": "vitest run",
+    "test:browser": "playwright test -c playwright-ct.config.ts"
+  }
 }