@embedpdf/vue 0.0.0-stage → 3.0.0-next.16

package/dist/state-M22NDJQo.cjs

@@ -0,0 +1,51 @@
+"use strict";
+const core = require("@embedpdf/core");
+const vue = require("vue");
+const capabilities = require("./capabilities-DVNJmgy7.cjs");
+function fieldRefs(whole, keys = Object.keys(whole.value)) {
+  return Object.freeze(
+    Object.fromEntries(
+      keys.map((key) => [key, vue.computed(() => whole.value[key])])
+    )
+  );
+}
+function stateComposable(declaration) {
+  function useDeclaredState(select) {
+    const scope = capabilities.useDocumentScope();
+    const { ensure } = declaration;
+    if (ensure) {
+      const capability = capabilities.useKernelValue(
+        (kernel) => kernel.tryCapability(declaration.token, scope.value ?? void 0)
+      );
+      vue.watch(
+        capability,
+        (current) => {
+          if (current) ensure(current).catch(() => {
+          });
+        },
+        { immediate: true }
+      );
+    }
+    const value = capabilities.useKernelValue((kernel) => {
+      const capability = kernel.tryCapability(declaration.token, scope.value ?? void 0);
+      const state = capability ? declaration.read(capability) : declaration.empty;
+      return select ? select(state) : state;
+    }, core.shallowEqual);
+    return select ? value : fieldRefs(value, Object.keys(declaration.empty));
+  }
+  return useDeclaredState;
+}
+function settingsComposable(token) {
+  function useSettings(select) {
+    const value = capabilities.useKernelValue((kernel) => {
+      const settings = kernel.settingsOf(token).getSettings();
+      return select ? select(settings) : settings;
+    }, core.shallowEqual);
+    return select ? value : fieldRefs(value);
+  }
+  return useSettings;
+}
+exports.fieldRefs = fieldRefs;
+exports.settingsComposable = settingsComposable;
+exports.stateComposable = stateComposable;
+//# sourceMappingURL=state-M22NDJQo.cjs.map

package/dist/state-M22NDJQo.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-M22NDJQo.cjs","sources":["../src/runtime/refs.ts","../src/state.ts"],"sourcesContent":["/**\n * A record read as refs, one per field: what a state or settings composable\n * returns without a selector, so `const { zoomLevel } = useStageState()` keeps\n * `zoomLevel` reactive after destructuring, and a template reads it unwrapped.\n */\nimport { computed } from 'vue';\nimport type { Ref } from 'vue';\n\n/** One read-only ref per field of `Value`. */\nexport type FieldRefs<Value extends object> = {\n  readonly [Key in keyof Value]-?: Readonly<Ref<Value[Key]>>;\n};\n\n/**\n * One computed ref per field of `whole`. Each field updates only when its own\n * value changes. The fields are the ones `whole` has now (`keys` names them\n * when they are known without a value): records read this way keep their\n * fields.\n */\nexport function fieldRefs<Value extends object>(\n  whole: Readonly<Ref<Value>>,\n  keys: readonly string[] = Object.keys(whole.value),\n): FieldRefs<Value> {\n  return Object.freeze(\n    Object.fromEntries(\n      keys.map((key) => [key, computed(() => (whole.value as Record<string, unknown>)[key])]),\n    ),\n  ) as unknown as FieldRefs<Value>;\n}\n","/**\n * Declared state and settings as Vue composables. A plugin declares its state\n * once with `defineState` and its settings once in its definition (both in\n * `@embedpdf/core`), and its Vue bindings are one line each:\n *\n *   export const useSearchState = stateComposable(searchState);\n *   export const useSearchSettings = settingsComposable(SearchToken);\n *\n * Without a selector they return one ref per field; with one, a single ref.\n */\nimport { shallowEqual } from '@embedpdf/core';\nimport type { CapabilityToken, SettingsOf, StateDeclaration } from '@embedpdf/core';\nimport { watch, type Ref } from 'vue';\nimport { useDocumentScope, useKernelValue } from './runtime/kernel';\nimport { fieldRefs } from './runtime/refs';\nimport type { FieldRefs } from './runtime/refs';\n\nexport type { FieldRefs } from './runtime/refs';\n\n/** A declared state's composable: refs for every field, or one ref for the value `select` picks. */\nexport interface StateComposable<State extends object> {\n  (): FieldRefs<State>;\n  <Selected>(select: (state: State) => Selected): Readonly<Ref<Selected>>;\n}\n\n/** A plugin's settings composable: refs for every setting, or one ref for the value `select` picks. */\nexport interface SettingsComposable<Settings extends object> {\n  (): FieldRefs<Settings>;\n  <Selected>(select: (settings: Settings) => Selected): Readonly<Ref<Selected>>;\n}\n\n/**\n * Turn a state declaration into its composable. It reads this subtree's\n * document (the nearest `<DocumentScope>`, else the active one) and reads the\n * declaration's `empty` while that document is missing or not ready, so it\n * works anywhere. A ref updates only when its value changes: the state, or the\n * value `select` picks from it, is compared with {@link shallowEqual}. State the\n * plugin loads on demand (the declaration's `ensure`) loads once a ready\n * document's capability is in scope, for every document the composable reads.\n */\nexport function stateComposable<Capability, State extends object>(\n  declaration: StateDeclaration<Capability, State>,\n): StateComposable<State> {\n  function useDeclaredState(): FieldRefs<State>;\n  function useDeclaredState<Selected>(select: (state: State) => Selected): Readonly<Ref<Selected>>;\n  function useDeclaredState<Selected>(select?: (state: State) => Selected) {\n    const scope = useDocumentScope();\n    const { ensure } = declaration;\n    if (ensure) {\n      const capability = useKernelValue((kernel) =>\n        kernel.tryCapability(declaration.token, scope.value ?? undefined),\n      );\n      // The state says when the load fails (its status), so the rejection has nothing to add.\n      watch(\n        capability,\n        (current) => {\n          if (current) ensure(current).catch(() => {});\n        },\n        { immediate: true },\n      );\n    }\n    // Resolved on every read: a document that closes reads as `empty` from\n    // then on, never through its closed capability.\n    const value = useKernelValue((kernel) => {\n      const capability = kernel.tryCapability(declaration.token, scope.value ?? undefined);\n      const state = capability ? declaration.read(capability) : declaration.empty;\n      return select ? select(state) : state;\n    }, shallowEqual);\n    return select\n      ? value\n      : fieldRefs(value as Readonly<Ref<State>>, Object.keys(declaration.empty));\n  }\n  return useDeclaredState;\n}\n\n/**\n * Turn a plugin's token into its settings composable. A plugin's settings\n * belong to the plugin as the app registered it, not to a document, so it\n * reads them through the kernel (`kernel.settingsOf`): it works before the\n * first document opens, and every document shows the same settings. A token\n * whose plugin isn't installed, or has no settings, throws: a setup mistake.\n */\nexport function settingsComposable<Capability>(\n  token: CapabilityToken<Capability>,\n): SettingsComposable<SettingsOf<Capability> & object> {\n  type Settings = SettingsOf<Capability> & object;\n  function useSettings(): FieldRefs<Settings>;\n  function useSettings<Selected>(select: (settings: Settings) => Selected): Readonly<Ref<Selected>>;\n  function useSettings<Selected>(select?: (settings: Settings) => Selected) {\n    const value = useKernelValue((kernel) => {\n      const settings = kernel.settingsOf(token).getSettings() as Settings;\n      return select ? select(settings) : settings;\n    }, shallowEqual);\n    return select ? value : fieldRefs(value as Readonly<Ref<Settings>>);\n  }\n  return useSettings;\n}\n"],"names":["computed","useDocumentScope","useKernelValue","watch","shallowEqual"],"mappings":";;;;AAmBO,SAAS,UACd,OACA,OAA0B,OAAO,KAAK,MAAM,KAAK,GAC/B;AAClB,SAAO,OAAO;AAAA,IACZ,OAAO;AAAA,MACL,KAAK,IAAI,CAAC,QAAQ,CAAC,KAAKA,aAAS,MAAO,MAAM,MAAkC,GAAG,CAAC,CAAC,CAAC;AAAA,IAAA;AAAA,EACxF;AAEJ;ACYO,SAAS,gBACd,aACwB;AAGxB,WAAS,iBAA2B,QAAqC;AACvE,UAAM,QAAQC,aAAAA,iBAAA;AACd,UAAM,EAAE,WAAW;AACnB,QAAI,QAAQ;AACV,YAAM,aAAaC,aAAAA;AAAAA,QAAe,CAAC,WACjC,OAAO,cAAc,YAAY,OAAO,MAAM,SAAS,MAAS;AAAA,MAAA;AAGlEC,UAAAA;AAAAA,QACE;AAAA,QACA,CAAC,YAAY;AACX,cAAI,QAAS,QAAO,OAAO,EAAE,MAAM,MAAM;AAAA,UAAC,CAAC;AAAA,QAC7C;AAAA,QACA,EAAE,WAAW,KAAA;AAAA,MAAK;AAAA,IAEtB;AAGA,UAAM,QAAQD,4BAAe,CAAC,WAAW;AACvC,YAAM,aAAa,OAAO,cAAc,YAAY,OAAO,MAAM,SAAS,MAAS;AACnF,YAAM,QAAQ,aAAa,YAAY,KAAK,UAAU,IAAI,YAAY;AACtE,aAAO,SAAS,OAAO,KAAK,IAAI;AAAA,IAClC,GAAGE,KAAAA,YAAY;AACf,WAAO,SACH,QACA,UAAU,OAA+B,OAAO,KAAK,YAAY,KAAK,CAAC;AAAA,EAC7E;AACA,SAAO;AACT;AASO,SAAS,mBACd,OACqD;AAIrD,WAAS,YAAsB,QAA2C;AACxE,UAAM,QAAQF,4BAAe,CAAC,WAAW;AACvC,YAAM,WAAW,OAAO,WAAW,KAAK,EAAE,YAAA;AAC1C,aAAO,SAAS,OAAO,QAAQ,IAAI;AAAA,IACrC,GAAGE,KAAAA,YAAY;AACf,WAAO,SAAS,QAAQ,UAAU,KAAgC;AAAA,EACpE;AACA,SAAO;AACT;;;;"}

package/dist/state.d.cts

@@ -0,0 +1,32 @@
+import type { CapabilityToken, SettingsOf, StateDeclaration } from '@embedpdf/core';
+import { type Ref } from 'vue';
+import type { FieldRefs } from './runtime/refs.cjs';
+export type { FieldRefs } from './runtime/refs.cjs';
+/** A declared state's composable: refs for every field, or one ref for the value `select` picks. */
+export interface StateComposable<State extends object> {
+    (): FieldRefs<State>;
+    <Selected>(select: (state: State) => Selected): Readonly<Ref<Selected>>;
+}
+/** A plugin's settings composable: refs for every setting, or one ref for the value `select` picks. */
+export interface SettingsComposable<Settings extends object> {
+    (): FieldRefs<Settings>;
+    <Selected>(select: (settings: Settings) => Selected): Readonly<Ref<Selected>>;
+}
+/**
+ * Turn a state declaration into its composable. It reads this subtree's
+ * document (the nearest `<DocumentScope>`, else the active one) and reads the
+ * declaration's `empty` while that document is missing or not ready, so it
+ * works anywhere. A ref updates only when its value changes: the state, or the
+ * value `select` picks from it, is compared with {@link shallowEqual}. State the
+ * plugin loads on demand (the declaration's `ensure`) loads once a ready
+ * document's capability is in scope, for every document the composable reads.
+ */
+export declare function stateComposable<Capability, State extends object>(declaration: StateDeclaration<Capability, State>): StateComposable<State>;
+/**
+ * Turn a plugin's token into its settings composable. A plugin's settings
+ * belong to the plugin as the app registered it, not to a document, so it
+ * reads them through the kernel (`kernel.settingsOf`): it works before the
+ * first document opens, and every document shows the same settings. A token
+ * whose plugin isn't installed, or has no settings, throws: a setup mistake.
+ */
+export declare function settingsComposable<Capability>(token: CapabilityToken<Capability>): SettingsComposable<SettingsOf<Capability> & object>;

package/dist/state.d.ts

@@ -0,0 +1,32 @@
+import type { CapabilityToken, SettingsOf, StateDeclaration } from '@embedpdf/core';
+import { type Ref } from 'vue';
+import type { FieldRefs } from './runtime/refs.js';
+export type { FieldRefs } from './runtime/refs.js';
+/** A declared state's composable: refs for every field, or one ref for the value `select` picks. */
+export interface StateComposable<State extends object> {
+    (): FieldRefs<State>;
+    <Selected>(select: (state: State) => Selected): Readonly<Ref<Selected>>;
+}
+/** A plugin's settings composable: refs for every setting, or one ref for the value `select` picks. */
+export interface SettingsComposable<Settings extends object> {
+    (): FieldRefs<Settings>;
+    <Selected>(select: (settings: Settings) => Selected): Readonly<Ref<Selected>>;
+}
+/**
+ * Turn a state declaration into its composable. It reads this subtree's
+ * document (the nearest `<DocumentScope>`, else the active one) and reads the
+ * declaration's `empty` while that document is missing or not ready, so it
+ * works anywhere. A ref updates only when its value changes: the state, or the
+ * value `select` picks from it, is compared with {@link shallowEqual}. State the
+ * plugin loads on demand (the declaration's `ensure`) loads once a ready
+ * document's capability is in scope, for every document the composable reads.
+ */
+export declare function stateComposable<Capability, State extends object>(declaration: StateDeclaration<Capability, State>): StateComposable<State>;
+/**
+ * Turn a plugin's token into its settings composable. A plugin's settings
+ * belong to the plugin as the app registered it, not to a document, so it
+ * reads them through the kernel (`kernel.settingsOf`): it works before the
+ * first document opens, and every document shows the same settings. A token
+ * whose plugin isn't installed, or has no settings, throws: a setup mistake.
+ */
+export declare function settingsComposable<Capability>(token: CapabilityToken<Capability>): SettingsComposable<SettingsOf<Capability> & object>;