@inkbar/vue 0.0.0-stage → 0.1.1

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

@@ -0,0 +1 @@
+{"version":3,"file":"useAnnotations.d.ts","sourceRoot":"","sources":["../../src/composables/useAnnotations.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAE/D,wBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAWX,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBACR,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBACf,MAAM,SAAS,OAAO,CAAC,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAClC,MAAM;kBACL,MAAM,EAAE;IACtB,+CAA+C;kBACjC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IACpB,sFAAsF;iBACzE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAIL,MAAM;EAEvB"}

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/compositions/DefaultToolbar.js

@@ -0,0 +1,7 @@
+import e from "./DefaultToolbar.vue_vue_type_script_setup_true_lang.js";
+//#region src/compositions/DefaultToolbar.vue
+var t = e;
+//#endregion
+export { t as default };
+
+//# sourceMappingURL=DefaultToolbar.js.map

package/dist/compositions/DefaultToolbar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DefaultToolbar.js","names":["_sfc_main","DefaultToolbar_vue_vue_type_script_setup_true_lang_default","DefaultToolbar_default"],"sources":["../../src/compositions/DefaultToolbar.vue"],"sourcesContent":["<script setup lang=\"ts\">\n/*\n * The standard toolbar: tools, zoom and page controls with icons. It adds no styles of its\n * own; the theme styles the `data-ink-*` hooks. Extra controls go in the default slot.\n */\nimport {\n  Hand,\n  Highlighter,\n  MessageSquare,\n  MousePointer2,\n  Square,\n  ZoomIn,\n  ZoomOut,\n} from '@lucide/vue'\n\nimport InkPageCount from '../components/InkPageCount.vue'\nimport InkPageInput from '../components/InkPageInput.vue'\nimport InkToolbar from '../components/InkToolbar.vue'\nimport InkToolButton from '../components/InkToolButton.vue'\nimport InkZoomIn from '../components/InkZoomIn.vue'\nimport InkZoomOut from '../components/InkZoomOut.vue'\nimport InkZoomSelect from '../components/InkZoomSelect.vue'\n\nwithDefaults(defineProps<{ label?: string }>(), { label: 'Document tools' })\n\nconst ICON = 18\n</script>\n\n<template>\n  <InkToolbar :label=\"label\" class=\"ink-default-toolbar\" data-ink-default-toolbar>\n    <div\n      class=\"ink-toolbar-group\"\n      data-ink-toolbar-group=\"tools\"\n      role=\"group\"\n      aria-label=\"Tools\"\n    >\n      <InkToolButton tool=\"view\"><Hand :size=\"ICON\" aria-hidden=\"true\" /></InkToolButton>\n      <InkToolButton tool=\"select\">\n        <MousePointer2 :size=\"ICON\" aria-hidden=\"true\" />\n      </InkToolButton>\n      <InkToolButton tool=\"highlight\">\n        <Highlighter :size=\"ICON\" aria-hidden=\"true\" />\n      </InkToolButton>\n      <InkToolButton tool=\"redact-area\">\n        <Square :size=\"ICON\" aria-hidden=\"true\" />\n      </InkToolButton>\n      <InkToolButton tool=\"note\">\n        <MessageSquare :size=\"ICON\" aria-hidden=\"true\" />\n      </InkToolButton>\n    </div>\n    <div\n      class=\"ink-toolbar-group\"\n      data-ink-toolbar-group=\"zoom\"\n      role=\"group\"\n      aria-label=\"Zoom\"\n    >\n      <InkZoomOut><ZoomOut :size=\"ICON\" aria-hidden=\"true\" /></InkZoomOut>\n      <InkZoomSelect />\n      <InkZoomIn><ZoomIn :size=\"ICON\" aria-hidden=\"true\" /></InkZoomIn>\n    </div>\n    <div\n      class=\"ink-toolbar-group\"\n      data-ink-toolbar-group=\"page\"\n      role=\"group\"\n      aria-label=\"Page\"\n    >\n      <InkPageInput />\n      <InkPageCount />\n    </div>\n    <slot />\n  </InkToolbar>\n</template>\n"],"mappings":""}

package/dist/compositions/DefaultToolbar.vue.d.ts

@@ -0,0 +1,19 @@
+type __VLS_Props = {
+    label?: string;
+};
+declare var __VLS_99: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_99) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    label: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=DefaultToolbar.vue.d.ts.map

package/dist/compositions/DefaultToolbar.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DefaultToolbar.vue.d.ts","sourceRoot":"","sources":["../../src/compositions/DefaultToolbar.vue"],"names":[],"mappings":"AAiGA,KAAK,WAAW,GAAG;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAwPtC,QAAA,IAAI,QAAQ,IAAY,CAAC;AACzB,KAAK,WAAW,GAAG,EAAE,GACnB;IAAE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,QAAQ,KAAK,GAAG,CAAA;CAAE,CAAC;AAGhD,QAAA,MAAM,UAAU;;6EAGd,CAAC;AACH,QAAA,MAAM,YAAY,EAAS,eAAe,CAAC,OAAO,UAAU,EAAE,WAAW,CAAC,CAAC;wBACtD,OAAO,YAAY;AAAxC,wBAAyC;AAWzC,KAAK,eAAe,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IAChC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KACV,CAAA;CACD,CAAC"}

package/dist/compositions/DefaultToolbar.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,100 @@
+import e from "../components/InkToolbar.js";
+import t from "../components/InkToolButton.js";
+import n from "../components/InkZoomIn.js";
+import r from "../components/InkZoomOut.js";
+import i from "../components/InkZoomSelect.js";
+import a from "../components/InkPageInput.js";
+import o from "../components/InkPageCount.js";
+import { createBlock as s, createElementVNode as c, createVNode as l, defineComponent as u, openBlock as d, renderSlot as f, unref as p, withCtx as m } from "vue";
+import { Hand as h, Highlighter as g, MessageSquare as _, MousePointer2 as v, Square as y, ZoomIn as b, ZoomOut as x } from "@lucide/vue";
+//#region src/compositions/DefaultToolbar.vue?vue&type=script&setup=true&lang.ts
+var S = {
+	class: "ink-toolbar-group",
+	"data-ink-toolbar-group": "tools",
+	role: "group",
+	"aria-label": "Tools"
+}, C = {
+	class: "ink-toolbar-group",
+	"data-ink-toolbar-group": "zoom",
+	role: "group",
+	"aria-label": "Zoom"
+}, w = {
+	class: "ink-toolbar-group",
+	"data-ink-toolbar-group": "page",
+	role: "group",
+	"aria-label": "Page"
+}, T = 18, E = /*@__PURE__*/ u({
+	__name: "DefaultToolbar",
+	props: { label: { default: "Document tools" } },
+	setup(u) {
+		return (E, D) => (d(), s(e, {
+			label: u.label,
+			class: "ink-default-toolbar",
+			"data-ink-default-toolbar": ""
+		}, {
+			default: m(() => [
+				c("div", S, [
+					l(t, { tool: "view" }, {
+						default: m(() => [l(p(h), {
+							size: T,
+							"aria-hidden": "true"
+						})]),
+						_: 1
+					}),
+					l(t, { tool: "select" }, {
+						default: m(() => [l(p(v), {
+							size: T,
+							"aria-hidden": "true"
+						})]),
+						_: 1
+					}),
+					l(t, { tool: "highlight" }, {
+						default: m(() => [l(p(g), {
+							size: T,
+							"aria-hidden": "true"
+						})]),
+						_: 1
+					}),
+					l(t, { tool: "redact-area" }, {
+						default: m(() => [l(p(y), {
+							size: T,
+							"aria-hidden": "true"
+						})]),
+						_: 1
+					}),
+					l(t, { tool: "note" }, {
+						default: m(() => [l(p(_), {
+							size: T,
+							"aria-hidden": "true"
+						})]),
+						_: 1
+					})
+				]),
+				c("div", C, [
+					l(r, null, {
+						default: m(() => [l(p(x), {
+							size: T,
+							"aria-hidden": "true"
+						})]),
+						_: 1
+					}),
+					l(i),
+					l(n, null, {
+						default: m(() => [l(p(b), {
+							size: T,
+							"aria-hidden": "true"
+						})]),
+						_: 1
+					})
+				]),
+				c("div", w, [l(a), l(o)]),
+				f(E.$slots, "default")
+			]),
+			_: 3
+		}, 8, ["label"]));
+	}
+});
+//#endregion
+export { E as default };
+
+//# sourceMappingURL=DefaultToolbar.vue_vue_type_script_setup_true_lang.js.map

package/dist/compositions/DefaultToolbar.vue_vue_type_script_setup_true_lang.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DefaultToolbar.vue_vue_type_script_setup_true_lang.js","names":["_openBlock","_createBlock","InkToolbar","_withCtx","_createElementVNode","_createVNode","InkToolButton","_unref","InkZoomOut","InkZoomSelect","InkZoomIn","InkPageInput","InkPageCount","_renderSlot","InkToolbar_default","InkToolButton_default","InkZoomIn_default","InkZoomOut_default","InkZoomSelect_default","InkPageInput_default","InkPageCount_default","_hoisted_1","_hoisted_2","_hoisted_3","ICON","DefaultToolbar_vue_vue_type_script_setup_true_lang_default","openBlock","createBlock","__props","withCtx","createElementVNode","createVNode","unref","Hand","MousePointer2","Highlighter","Square","MessageSquare","ZoomOut","ZoomIn","renderSlot","_ctx"],"sources":["../../src/compositions/DefaultToolbar.vue"],"sourcesContent":["<script setup lang=\"ts\">\n/*\n * The standard toolbar: tools, zoom and page controls with icons. It adds no styles of its\n * own; the theme styles the `data-ink-*` hooks. Extra controls go in the default slot.\n */\nimport {\n  Hand,\n  Highlighter,\n  MessageSquare,\n  MousePointer2,\n  Square,\n  ZoomIn,\n  ZoomOut,\n} from '@lucide/vue'\n\nimport InkPageCount from '../components/InkPageCount.vue'\nimport InkPageInput from '../components/InkPageInput.vue'\nimport InkToolbar from '../components/InkToolbar.vue'\nimport InkToolButton from '../components/InkToolButton.vue'\nimport InkZoomIn from '../components/InkZoomIn.vue'\nimport InkZoomOut from '../components/InkZoomOut.vue'\nimport InkZoomSelect from '../components/InkZoomSelect.vue'\n\nwithDefaults(defineProps<{ label?: string }>(), { label: 'Document tools' })\n\nconst ICON = 18\n</script>\n\n<template>\n  <InkToolbar :label=\"label\" class=\"ink-default-toolbar\" data-ink-default-toolbar>\n    <div\n      class=\"ink-toolbar-group\"\n      data-ink-toolbar-group=\"tools\"\n      role=\"group\"\n      aria-label=\"Tools\"\n    >\n      <InkToolButton tool=\"view\"><Hand :size=\"ICON\" aria-hidden=\"true\" /></InkToolButton>\n      <InkToolButton tool=\"select\">\n        <MousePointer2 :size=\"ICON\" aria-hidden=\"true\" />\n      </InkToolButton>\n      <InkToolButton tool=\"highlight\">\n        <Highlighter :size=\"ICON\" aria-hidden=\"true\" />\n      </InkToolButton>\n      <InkToolButton tool=\"redact-area\">\n        <Square :size=\"ICON\" aria-hidden=\"true\" />\n      </InkToolButton>\n      <InkToolButton tool=\"note\">\n        <MessageSquare :size=\"ICON\" aria-hidden=\"true\" />\n      </InkToolButton>\n    </div>\n    <div\n      class=\"ink-toolbar-group\"\n      data-ink-toolbar-group=\"zoom\"\n      role=\"group\"\n      aria-label=\"Zoom\"\n    >\n      <InkZoomOut><ZoomOut :size=\"ICON\" aria-hidden=\"true\" /></InkZoomOut>\n      <InkZoomSelect />\n      <InkZoomIn><ZoomIn :size=\"ICON\" aria-hidden=\"true\" /></InkZoomIn>\n    </div>\n    <div\n      class=\"ink-toolbar-group\"\n      data-ink-toolbar-group=\"page\"\n      role=\"group\"\n      aria-label=\"Page\"\n    >\n      <InkPageInput />\n      <InkPageCount />\n    </div>\n    <slot />\n  </InkToolbar>\n</template>\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;GAyBMwB,IAAO;;;;oBAIXxB,EAAA,GAAAC,EAyCaC,GAAA;GAzCA,OAAO0B,EAAA;GAAO,OAAM;GAAsB,4BAAA;;GACrD,SAAAzB,QAmBM;IAnBNC,EAmBM,OAnBNiB,GAmBM;KAbJhB,EAAmFC,GAAA,EAApE,MAAK,OAAM,GAAA;MAAC,SAAAH,QAAwC,CAAxCE,EAAwCE,EAAA0B,CAAA,GAAA;OAAjC,MAAMT;OAAM,eAAY;;;;KAC1DnB,EAEgBC,GAAA,EAFD,MAAK,SAAQ,GAAA;MAC1B,SAAAH,QAAiD,CAAjDE,EAAiDE,EAAA2B,CAAA,GAAA;OAAjC,MAAMV;OAAM,eAAY;;;;KAE1CnB,EAEgBC,GAAA,EAFD,MAAK,YAAW,GAAA;MAC7B,SAAAH,QAA+C,CAA/CE,EAA+CE,EAAA4B,CAAA,GAAA;OAAjC,MAAMX;OAAM,eAAY;;;;KAExCnB,EAEgBC,GAAA,EAFD,MAAK,cAAa,GAAA;MAC/B,SAAAH,QAA0C,CAA1CE,EAA0CE,EAAA6B,CAAA,GAAA;OAAjC,MAAMZ;OAAM,eAAY;;;;KAEnCnB,EAEgBC,GAAA,EAFD,MAAK,OAAM,GAAA;MACxB,SAAAH,QAAiD,CAAjDE,EAAiDE,EAAA8B,CAAA,GAAA;OAAjC,MAAMb;OAAM,eAAY;;;;;IAG5CpB,EASM,OATNkB,GASM;KAHJjB,EAAoEG,GAAA,MAAA;MAAxD,SAAAL,QAA2C,CAA3CE,EAA2CE,EAAA+B,CAAA,GAAA;OAAjC,MAAMd;OAAM,eAAY;;;;KAC9CnB,EAAiBI,CAAA;KACjBJ,EAAiEK,GAAA,MAAA;MAAtD,SAAAP,QAA0C,CAA1CE,EAA0CE,EAAAgC,CAAA,GAAA;OAAjC,MAAMf;OAAM,eAAY;;;;;IAE9CpB,EAQM,OARNmB,GAQM,CAFJlB,EAAgBM,CAAA,GAChBN,EAAgBO,CAAA,CAAA,CAAA;IAElBC,EAAQ4B,EAAA,QAAA,SAAA"}

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,29 @@
+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 InkToolButton } from './components/InkToolButton.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 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';
+export { default as DefaultToolbar } from './compositions/DefaultToolbar.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,aAAa,EAAE,MAAM,gCAAgC,CAAA;AACzE,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,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;AAC3C,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,mCAAmC,CAAA"}

package/dist/index.js

@@ -0,0 +1,25 @@
+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/InkToolButton.js";
+import g from "./components/InkZoomIn.js";
+import _ from "./components/InkZoomOut.js";
+import v from "./components/InkZoomSelect.js";
+import y from "./components/InkPageInput.js";
+import b from "./components/InkPageCount.js";
+import x from "./components/InkNotePopover.js";
+import S from "./components/InkSuggestionCard.js";
+import C from "./compositions/DefaultToolbar.js";
+export { C as DefaultToolbar, d as InkAnnotation, x as InkNotePopover, f as InkPage, b as InkPageCount, y as InkPageInput, n as InkRoot, S as InkSuggestionCard, h as InkToolButton, m as InkToolbar, p as InkViewport, g as InkZoomIn, _ as InkZoomOut, v 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