@graffiti-garden/wrapper-vue 0.7.1 → 1.0.3

package/dist/node/composables.d.ts

@@ -1,75 +0,0 @@
-import { Ref, MaybeRefOrGetter } from 'vue';
-import { GraffitiObjectUrl, GraffitiObject, GraffitiSession, JSONSchema } from '@graffiti-garden/api';
-/**
- * The [Graffiti.discover](https://api.graffiti.garden/classes/Graffiti.html#discover)
- * method as a reactive [composable](https://vuejs.org/guide/reusability/composables.html)
- * for use in the Vue [composition API](https://vuejs.org/guide/introduction.html#composition-api).
- *
- * Its corresponding renderless component is {@link GraffitiDiscover}.
- *
- * The arguments of this composable as the same as Graffiti.discover,
- * only they can also be [Refs](https://vuejs.org/api/reactivity-core.html#ref)
- * or [getters](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/get#description).
- * As they change the output will automatically update.
- * Reactivity only triggers when the root array or object changes,
- * not when the elements or properties change.
- * If you need deep reactivity, wrap your argument in a getter.
- */
-export declare function useGraffitiDiscover<Schema extends JSONSchema>(channels: MaybeRefOrGetter<string[]>, schema: MaybeRefOrGetter<Schema>, 
-/**
- * If the session is `undefined`, the global session,
- * {@link ComponentCustomProperties.$graffitiSession | $graffitiSession},
- * will be used. Otherwise, the provided value will be used.
- */
-session?: MaybeRefOrGetter<GraffitiSession | undefined | null>, autopoll?: MaybeRefOrGetter<boolean>): {
-    objects: Ref<GraffitiObject<Schema>[]>;
-    poll: () => Promise<void>;
-    isInitialPolling: Ref<boolean>;
-};
-/**
- * The [Graffiti.get](https://api.graffiti.garden/classes/Graffiti.html#get)
- * method as a reactive [composable](https://vuejs.org/guide/reusability/composables.html)
- * for use in the Vue [composition API](https://vuejs.org/guide/introduction.html#composition-api).
- *
- * Its corresponding renderless component is {@link GraffitiGet}.
- *
- * The arguments of this composable as the same as Graffiti.get,
- * only they can also be [Refs](https://vuejs.org/api/reactivity-core.html#ref)
- * or [getters](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/get#description).
- * As they change the output will automatically update.
- * Reactivity only triggers when the root array or object changes,
- * not when the elements or properties change.
- * If you need deep reactivity, wrap your argument in a getter.
- */
-export declare function useGraffitiGet<Schema extends JSONSchema>(locationOrUri: MaybeRefOrGetter<GraffitiObjectUrl | string>, schema: MaybeRefOrGetter<Schema>, 
-/**
- * If the session is `undefined`, the global session,
- * {@link ComponentCustomProperties.$graffitiSession | $graffitiSession},
- * will be used. Otherwise, the provided value will be used.
- */
-session?: MaybeRefOrGetter<GraffitiSession | undefined | null>, autopoll?: MaybeRefOrGetter<boolean>): {
-    object: Ref<GraffitiObject<Schema> | null | undefined>;
-    poll: () => Promise<void>;
-    isInitialPolling: Ref<boolean>;
-};
-/**
- * The [Graffiti.recoverOrphans](https://api.graffiti.garden/classes/Graffiti.html#recoverorphans)
- * method as a reactive [composable](https://vuejs.org/guide/reusability/composables.html)
- * for use in the Vue [composition API](https://vuejs.org/guide/introduction.html#composition-api).
- *
- * Its corresponding renderless component is {@link GraffitiRecoverOrphans}.
- *
- * The arguments of this composable as the same as Graffiti.get,
- * only they can also be [Refs](https://vuejs.org/api/reactivity-core.html#ref)
- * or [getters](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/get#description).
- * As they change the output will automatically update.
- * Reactivity only triggers when the root array or object changes,
- * not when the elements or properties change.
- * If you need deep reactivity, wrap your argument in a getter.
- */
-export declare function useGraffitiRecoverOrphans<Schema extends JSONSchema>(schema: MaybeRefOrGetter<Schema>, session: MaybeRefOrGetter<GraffitiSession>, autopoll?: MaybeRefOrGetter<boolean>): {
-    objects: Ref<GraffitiObject<Schema>[]>;
-    poll: () => Promise<void>;
-    isInitialPolling: Ref<boolean>;
-};
-//# sourceMappingURL=composables.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"composables.d.ts","sourceRoot":"","sources":["../../src/composables.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,GAAG,EAAE,gBAAgB,EAAE,MAAM,KAAK,CAAC;AACjD,OAAO,KAAK,EACV,iBAAiB,EACjB,cAAc,EACd,eAAe,EACf,UAAU,EAEX,MAAM,sBAAsB,CAAC;AA8G9B;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,SAAS,UAAU,EAC3D,QAAQ,EAAE,gBAAgB,CAAC,MAAM,EAAE,CAAC,EACpC,MAAM,EAAE,gBAAgB,CAAC,MAAM,CAAC;AAChC;;;;GAIG;AACH,OAAO,CAAC,EAAE,gBAAgB,CAAC,eAAe,GAAG,SAAS,GAAG,IAAI,CAAC,EAC9D,QAAQ,GAAE,gBAAgB,CAAC,OAAO,CAAS,GAC1C;IACD,OAAO,EAAE,GAAG,CAAC,cAAc,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;IACvC,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,gBAAgB,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;CAChC,CA6CA;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,MAAM,SAAS,UAAU,EACtD,aAAa,EAAE,gBAAgB,CAAC,iBAAiB,GAAG,MAAM,CAAC,EAC3D,MAAM,EAAE,gBAAgB,CAAC,MAAM,CAAC;AAChC;;;;GAIG;AACH,OAAO,CAAC,EAAE,gBAAgB,CAAC,eAAe,GAAG,SAAS,GAAG,IAAI,CAAC,EAC9D,QAAQ,GAAE,gBAAgB,CAAC,OAAO,CAAS,GAC1C;IACD,MAAM,EAAE,GAAG,CAAC,cAAc,CAAC,MAAM,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC,CAAC;IACvD,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,gBAAgB,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;CAChC,CAkDA;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,SAAS,UAAU,EACjE,MAAM,EAAE,gBAAgB,CAAC,MAAM,CAAC,EAChC,OAAO,EAAE,gBAAgB,CAAC,eAAe,CAAC,EAC1C,QAAQ,GAAE,gBAAgB,CAAC,OAAO,CAAS,GAC1C;IACD,OAAO,EAAE,GAAG,CAAC,cAAc,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;IACvC,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,gBAAgB,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;CAChC,CA4CA"}

package/dist/node/pollers.d.ts

@@ -1,28 +0,0 @@
-import { JSONSchema, GraffitiObject, GraffitiObjectStreamContinueEntry, GraffitiObjectStream, GraffitiObjectStreamContinue } from '@graffiti-garden/api';
-export declare abstract class Poller<Schema extends JSONSchema> {
-    abstract poll(onEntry: (entry: GraffitiObjectStreamContinueEntry<Schema> | null | "clear") => void): Promise<void>;
-    abstract clear(): void;
-}
-/**
- * Polls for a single object and calls onValue with the result.
- */
-export declare class GetPoller<Schema extends JSONSchema> implements Poller<Schema> {
-    readonly getter: () => Promise<GraffitiObject<Schema>>;
-    constructor(getter: () => Promise<GraffitiObject<Schema>>);
-    poll: Poller<Schema>["poll"];
-    clear(): void;
-}
-/**
- * Polls for multiple objects and calls `onObject` with the result.
- * If `poll` is called multiple times, it doesn't poll the results
- * entirely from scratch, but instead only polls the new results.
- */
-export declare class StreamPoller<Schema extends JSONSchema> implements Poller<Schema> {
-    readonly streamFactory: () => GraffitiObjectStream<Schema>;
-    iterator: GraffitiObjectStreamContinue<Schema> | undefined;
-    continue: (() => GraffitiObjectStreamContinue<Schema>) | undefined;
-    constructor(streamFactory: () => GraffitiObjectStream<Schema>);
-    clear(): void;
-    poll: Poller<Schema>["poll"];
-}
-//# sourceMappingURL=pollers.d.ts.map

package/dist/node/pollers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pollers.d.ts","sourceRoot":"","sources":["../../src/pollers.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,UAAU,EACf,KAAK,cAAc,EAEnB,KAAK,iCAAiC,EACtC,KAAK,oBAAoB,EACzB,KAAK,4BAA4B,EAElC,MAAM,sBAAsB,CAAC;AAE9B,8BAAsB,MAAM,CAAC,MAAM,SAAS,UAAU;IACpD,QAAQ,CAAC,IAAI,CACX,OAAO,EAAE,CACP,KAAK,EAAE,iCAAiC,CAAC,MAAM,CAAC,GAAG,IAAI,GAAG,OAAO,KAC9D,IAAI,GACR,OAAO,CAAC,IAAI,CAAC;IAChB,QAAQ,CAAC,KAAK,IAAI,IAAI;CACvB;AAED;;GAEG;AACH,qBAAa,SAAS,CAAC,MAAM,SAAS,UAAU,CAAE,YAAW,MAAM,CAAC,MAAM,CAAC;IAC7D,QAAQ,CAAC,MAAM,EAAE,MAAM,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;gBAA7C,MAAM,EAAE,MAAM,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;IAElE,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAc1B;IAEF,KAAK;CACN;AAED;;;;GAIG;AACH,qBAAa,YAAY,CAAC,MAAM,SAAS,UAAU,CAAE,YAAW,MAAM,CAAC,MAAM,CAAC;IAIhE,QAAQ,CAAC,aAAa,EAAE,MAAM,oBAAoB,CAAC,MAAM,CAAC;IAHtE,QAAQ,EAAE,4BAA4B,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC;IAC3D,QAAQ,EAAE,CAAC,MAAM,4BAA4B,CAAC,MAAM,CAAC,CAAC,GAAG,SAAS,CAAC;gBAE9C,aAAa,EAAE,MAAM,oBAAoB,CAAC,MAAM,CAAC;IAEtE,KAAK;IAYL,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAiD1B;CACH"}

package/dist/node/reducers.d.ts

@@ -1,37 +0,0 @@
-import { Ref } from 'vue';
-import { GraffitiObject, Graffiti, JSONSchema, GraffitiObjectStreamContinueEntry } from '@graffiti-garden/api';
-export declare abstract class Reducer<Schema extends JSONSchema> {
-    abstract clear(): void;
-    abstract onEntry(entry: GraffitiObjectStreamContinueEntry<Schema> | null | "clear"): void;
-}
-/**
- * Retrieves multiple Graffiti objects and retains
- * the most recent one as the `result` property (a Vue ref).
- * Before any objects have been received, the result
- * is `undefined`. If the object has been deleted,
- * the result is `null`.
- */
-export declare class SingletonReducer<Schema extends JSONSchema> implements Reducer<Schema> {
-    readonly entry: Ref<GraffitiObjectStreamContinueEntry<Schema> | null | undefined>;
-    get result(): Ref<GraffitiObject<Schema> | null | undefined>;
-    clear(): void;
-    onEntry(entry: GraffitiObjectStreamContinueEntry<Schema> | null | "clear"): void;
-}
-/**
- * Retrieves multiple Graffiti objects and retains
- * the most recent one per URI as the `results` property (a Vue ref).
- * If multiple objects are received concurrently,
- * they are processed in batches every `REFRESH_RATE` milliseconds
- * to avoid freezing the interface.
- */
-export declare class ArrayReducer<Schema extends JSONSchema> implements Reducer<Schema> {
-    readonly graffiti: Graffiti;
-    readonly results: Ref<GraffitiObject<Schema>[]>;
-    readonly resultsRaw: Map<string, GraffitiObjectStreamContinueEntry<Schema>>;
-    batchFlattenTimer: ReturnType<typeof setTimeout> | undefined;
-    constructor(graffiti: Graffiti);
-    clear(): void;
-    flattenResults(): void;
-    onEntry(entry: GraffitiObjectStreamContinueEntry<Schema> | null | "clear"): void;
-}
-//# sourceMappingURL=reducers.d.ts.map

package/dist/node/reducers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"reducers.d.ts","sourceRoot":"","sources":["../../src/reducers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AAC/B,OAAO,KAAK,EACV,cAAc,EACd,QAAQ,EACR,UAAU,EACV,iCAAiC,EAClC,MAAM,sBAAsB,CAAC;AAE9B,8BAAsB,OAAO,CAAC,MAAM,SAAS,UAAU;IACrD,QAAQ,CAAC,KAAK,IAAI,IAAI;IACtB,QAAQ,CAAC,OAAO,CACd,KAAK,EAAE,iCAAiC,CAAC,MAAM,CAAC,GAAG,IAAI,GAAG,OAAO,GAChE,IAAI;CACR;AAeD;;;;;;GAMG;AACH,qBAAa,gBAAgB,CAAC,MAAM,SAAS,UAAU,CACrD,YAAW,OAAO,CAAC,MAAM,CAAC;IAE1B,QAAQ,CAAC,KAAK,EAAE,GAAG,CACjB,iCAAiC,CAAC,MAAM,CAAC,GAAG,IAAI,GAAG,SAAS,CAC7D,CAAS;IAEV,IAAI,MAAM,IAAI,GAAG,CAAC,cAAc,CAAC,MAAM,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC,CAO3D;IAED,KAAK;IAIL,OAAO,CAAC,KAAK,EAAE,iCAAiC,CAAC,MAAM,CAAC,GAAG,IAAI,GAAG,OAAO;CAS1E;AAED;;;;;;GAMG;AACH,qBAAa,YAAY,CAAC,MAAM,SAAS,UAAU,CACjD,YAAW,OAAO,CAAC,MAAM,CAAC;IAOd,QAAQ,CAAC,QAAQ,EAAE,QAAQ;IALvC,QAAQ,CAAC,OAAO,EAAE,GAAG,CAAC,cAAc,CAAC,MAAM,CAAC,EAAE,CAAC,CAAW;IAC1D,QAAQ,CAAC,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,iCAAiC,CAAC,MAAM,CAAC,CAAC,CAC/D;IACZ,iBAAiB,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,GAAG,SAAS,CAAC;gBAExC,QAAQ,EAAE,QAAQ;IAEvC,KAAK;IAOL,cAAc;IAWd,OAAO,CAAC,KAAK,EAAE,iCAAiC,CAAC,MAAM,CAAC,GAAG,IAAI,GAAG,OAAO;CAqB1E"}

package/src/RecoverOrphans.vue

@@ -1,37 +0,0 @@
-<script setup lang="ts" generic="Schema extends JSONSchema">
-import { toRef } from "vue";
-import type {
-    GraffitiSession,
-    JSONSchema,
-    GraffitiObject,
-} from "@graffiti-garden/api";
-import { useGraffitiRecoverOrphans } from "./composables";
-
-const props = defineProps<{
-    schema: Schema;
-    session: GraffitiSession;
-    autopoll?: boolean;
-}>();
-
-defineSlots<{
-    default?(props: {
-        objects: GraffitiObject<Schema>[];
-        poll: () => void;
-        isInitialPolling: boolean;
-    }): any;
-}>();
-
-const { objects, poll, isInitialPolling } = useGraffitiRecoverOrphans<Schema>(
-    toRef(props, "schema"),
-    toRef(props, "session"),
-    toRef(props, "autopoll"),
-);
-</script>
-
-<template>
-    <slot
-        :objects="objects"
-        :poll="poll"
-        :isInitialPolling="isInitialPolling"
-    ></slot>
-</template>

package/src/composables.ts

@@ -1,343 +0,0 @@
-import { onScopeDispose, ref, toValue, watch } from "vue";
-import type { Ref, MaybeRefOrGetter } from "vue";
-import type {
-  GraffitiObjectUrl,
-  GraffitiObject,
-  GraffitiSession,
-  JSONSchema,
-  GraffitiObjectStreamContinueEntry,
-} from "@graffiti-garden/api";
-import { useGraffitiSynchronize, useGraffitiSession } from "./globals";
-import { GetPoller, Poller, StreamPoller } from "./pollers";
-import { ArrayReducer, Reducer, SingletonReducer } from "./reducers";
-
-function makeComposable<Schema extends JSONSchema>(
-  reducer: Reducer<Schema>,
-  poller: Poller<Schema>,
-  synchronizeFactory: () => AsyncGenerator<
-    GraffitiObjectStreamContinueEntry<Schema>
-  >,
-  toWatch: readonly (() => any)[],
-  autopoll: MaybeRefOrGetter<boolean>,
-) {
-  let synchronizeIterator:
-    | AsyncGenerator<GraffitiObjectStreamContinueEntry<Schema>>
-    | undefined;
-  async function pollSynchronize() {
-    synchronizeIterator = synchronizeFactory();
-    for await (const result of synchronizeIterator) {
-      if (result.error) {
-        console.error(result.error);
-        continue;
-      }
-      reducer.onEntry(result);
-    }
-  }
-
-  let isAlreadyPolling = false;
-  let innerPoll: (() => Promise<void>) | undefined;
-  const poll = async () => {
-    if (isAlreadyPolling) return;
-    if (!innerPoll) return;
-    const myPoll = innerPoll;
-    isAlreadyPolling = true;
-    try {
-      await myPoll();
-    } finally {
-      if (myPoll !== innerPoll) return;
-      isAlreadyPolling = false;
-      if (toValue(autopoll)) {
-        poll();
-      }
-    }
-  };
-
-  const isInitialPolling = ref(false);
-  watch(
-    toWatch,
-    async (newValue, oldValue) => {
-      // Catch unnecessary updates
-      if (JSON.stringify(newValue) === JSON.stringify(oldValue)) {
-        return;
-      }
-
-      synchronizeIterator?.return(null);
-      reducer.clear();
-      poller.clear();
-
-      pollSynchronize();
-
-      innerPoll = () => poller.poll(reducer.onEntry.bind(reducer));
-      const myPoll = innerPoll;
-
-      isAlreadyPolling = false;
-
-      isInitialPolling.value = true;
-      try {
-        await poll();
-      } finally {
-        if (myPoll !== innerPoll) return;
-        isInitialPolling.value = false;
-      }
-    },
-    {
-      immediate: true,
-    },
-  );
-  onScopeDispose(() => {
-    synchronizeIterator?.return(null);
-    reducer.clear();
-    poller.clear();
-    innerPoll = undefined;
-  });
-
-  return { poll, isInitialPolling };
-}
-
-function toSessionGetter(
-  sessionInjected: ReturnType<typeof useGraffitiSession>,
-  session?: MaybeRefOrGetter<GraffitiSession | undefined | null>,
-) {
-  return () => {
-    const sessionValue = toValue(session);
-    if (sessionValue === undefined) {
-      return sessionInjected?.value;
-    } else {
-      return sessionValue;
-    }
-  };
-}
-
-function callGetters<T extends readonly (() => any)[]>(
-  getters: T,
-): {
-  [K in keyof T]: ReturnType<T[K]>;
-} {
-  return getters.map((fn) => fn()) as any;
-}
-
-/**
- * The [Graffiti.discover](https://api.graffiti.garden/classes/Graffiti.html#discover)
- * method as a reactive [composable](https://vuejs.org/guide/reusability/composables.html)
- * for use in the Vue [composition API](https://vuejs.org/guide/introduction.html#composition-api).
- *
- * Its corresponding renderless component is {@link GraffitiDiscover}.
- *
- * The arguments of this composable as the same as Graffiti.discover,
- * only they can also be [Refs](https://vuejs.org/api/reactivity-core.html#ref)
- * or [getters](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/get#description).
- * As they change the output will automatically update.
- * Reactivity only triggers when the root array or object changes,
- * not when the elements or properties change.
- * If you need deep reactivity, wrap your argument in a getter.
- */
-export function useGraffitiDiscover<Schema extends JSONSchema>(
-  channels: MaybeRefOrGetter<string[]>,
-  schema: MaybeRefOrGetter<Schema>,
-  /**
-   * If the session is `undefined`, the global session,
-   * {@link ComponentCustomProperties.$graffitiSession | $graffitiSession},
-   * will be used. Otherwise, the provided value will be used.
-   */
-  session?: MaybeRefOrGetter<GraffitiSession | undefined | null>,
-  autopoll: MaybeRefOrGetter<boolean> = false,
-): {
-  objects: Ref<GraffitiObject<Schema>[]>;
-  poll: () => Promise<void>;
-  isInitialPolling: Ref<boolean>;
-} {
-  const graffiti = useGraffitiSynchronize();
-  const sessionInjected = useGraffitiSession();
-
-  const channelsGetter = () => toValue(channels);
-  const schemaGetter = () => toValue(schema);
-  const sessionGetter = toSessionGetter(sessionInjected, session);
-  const argGetters = [channelsGetter, schemaGetter, sessionGetter] as const;
-
-  const synchronizeFactory = () =>
-    graffiti.synchronizeDiscover(...callGetters(argGetters));
-  const streamFactory = () => graffiti.discover(...callGetters(argGetters));
-
-  const reducer = new ArrayReducer<Schema>(graffiti);
-  const poller = new StreamPoller<Schema>(streamFactory);
-
-  const { poll, isInitialPolling } = makeComposable<Schema>(
-    reducer,
-    poller,
-    synchronizeFactory,
-    argGetters,
-    autopoll,
-  );
-
-  return {
-    /**
-     * A [ref](https://vuejs.org/api/reactivity-core.html#ref) that contains
-     * an array of Graffiti objects.
-     */
-    objects: reducer.results,
-    /**
-     * A method to poll for new results.
-     */
-    poll,
-    /**
-     * A boolean [ref](https://vuejs.org/api/reactivity-core.html#ref)
-     * that indicates if the *first* poll is currently running.
-     * Useful to show a loading spinner or disable a button.
-     *
-     * This also tracks new polls when the arguments have changed,
-     * but it does not track ongoing polls from either calling
-     * {@link poll} or using the `autopoll` argument.
-     */
-    isInitialPolling,
-  };
-}
-
-/**
- * The [Graffiti.get](https://api.graffiti.garden/classes/Graffiti.html#get)
- * method as a reactive [composable](https://vuejs.org/guide/reusability/composables.html)
- * for use in the Vue [composition API](https://vuejs.org/guide/introduction.html#composition-api).
- *
- * Its corresponding renderless component is {@link GraffitiGet}.
- *
- * The arguments of this composable as the same as Graffiti.get,
- * only they can also be [Refs](https://vuejs.org/api/reactivity-core.html#ref)
- * or [getters](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/get#description).
- * As they change the output will automatically update.
- * Reactivity only triggers when the root array or object changes,
- * not when the elements or properties change.
- * If you need deep reactivity, wrap your argument in a getter.
- */
-export function useGraffitiGet<Schema extends JSONSchema>(
-  locationOrUri: MaybeRefOrGetter<GraffitiObjectUrl | string>,
-  schema: MaybeRefOrGetter<Schema>,
-  /**
-   * If the session is `undefined`, the global session,
-   * {@link ComponentCustomProperties.$graffitiSession | $graffitiSession},
-   * will be used. Otherwise, the provided value will be used.
-   */
-  session?: MaybeRefOrGetter<GraffitiSession | undefined | null>,
-  autopoll: MaybeRefOrGetter<boolean> = false,
-): {
-  object: Ref<GraffitiObject<Schema> | null | undefined>;
-  poll: () => Promise<void>;
-  isInitialPolling: Ref<boolean>;
-} {
-  const graffiti = useGraffitiSynchronize();
-  const sessionInjected = useGraffitiSession();
-
-  const locationOrUriGetter = () => toValue(locationOrUri);
-  const schemaGetter = () => toValue(schema);
-  const sessionGetter = toSessionGetter(sessionInjected, session);
-  const argGetters = [
-    locationOrUriGetter,
-    schemaGetter,
-    sessionGetter,
-  ] as const;
-
-  const synchronizeFactory = () =>
-    graffiti.synchronizeGet(...callGetters(argGetters));
-
-  const reducer = new SingletonReducer<Schema>();
-  const getter = () => graffiti.get<Schema>(...callGetters(argGetters));
-  const poller = new GetPoller<Schema>(getter);
-
-  const { poll, isInitialPolling } = makeComposable<Schema>(
-    reducer,
-    poller,
-    synchronizeFactory,
-    argGetters,
-    autopoll,
-  );
-
-  return {
-    /**
-     * A [ref](https://vuejs.org/api/reactivity-core.html#ref) that contains
-     * the retrieved Graffiti object, if it exists. If the object has been deleted,
-     * the result is `null`. If the object is still being fetched, the result is `undefined`.
-     */
-    object: reducer.result,
-    /**
-     * A method to poll for new results.
-     */
-    poll,
-    /**
-     * A boolean [ref](https://vuejs.org/api/reactivity-core.html#ref)
-     * that indicates if the *first* poll is currently running.
-     * Useful to show a loading spinner or disable a button.
-     *
-     * This also tracks new polls when the arguments have changed,
-     * but it does not track ongoing polls from either calling
-     * {@link poll} or using the `autopoll` argument.
-     */
-    isInitialPolling,
-  };
-}
-
-/**
- * The [Graffiti.recoverOrphans](https://api.graffiti.garden/classes/Graffiti.html#recoverorphans)
- * method as a reactive [composable](https://vuejs.org/guide/reusability/composables.html)
- * for use in the Vue [composition API](https://vuejs.org/guide/introduction.html#composition-api).
- *
- * Its corresponding renderless component is {@link GraffitiRecoverOrphans}.
- *
- * The arguments of this composable as the same as Graffiti.get,
- * only they can also be [Refs](https://vuejs.org/api/reactivity-core.html#ref)
- * or [getters](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/get#description).
- * As they change the output will automatically update.
- * Reactivity only triggers when the root array or object changes,
- * not when the elements or properties change.
- * If you need deep reactivity, wrap your argument in a getter.
- */
-export function useGraffitiRecoverOrphans<Schema extends JSONSchema>(
-  schema: MaybeRefOrGetter<Schema>,
-  session: MaybeRefOrGetter<GraffitiSession>,
-  autopoll: MaybeRefOrGetter<boolean> = false,
-): {
-  objects: Ref<GraffitiObject<Schema>[]>;
-  poll: () => Promise<void>;
-  isInitialPolling: Ref<boolean>;
-} {
-  const graffiti = useGraffitiSynchronize();
-
-  const schemaGetter = () => toValue(schema);
-  const sessionGetter = () => toValue(session);
-  const argGetters = [schemaGetter, sessionGetter] as const;
-
-  const synchronizeFactory = () =>
-    graffiti.synchronizeRecoverOrphans(...callGetters(argGetters));
-
-  const reducer = new ArrayReducer<Schema>(graffiti);
-  const streamFactory = () =>
-    graffiti.recoverOrphans<Schema>(...callGetters(argGetters));
-  const poller = new StreamPoller<Schema>(streamFactory);
-
-  const { poll, isInitialPolling } = makeComposable<Schema>(
-    reducer,
-    poller,
-    synchronizeFactory,
-    argGetters,
-    autopoll,
-  );
-
-  return {
-    /**
-     * A [ref](https://vuejs.org/api/reactivity-core.html#ref) that contains
-     * an array of Graffiti objects.
-     */
-    objects: reducer.results,
-    /**
-     * A method to poll for new results.
-     */
-    poll,
-    /**
-     * A boolean [ref](https://vuejs.org/api/reactivity-core.html#ref)
-     * that indicates if the *first* poll is currently running.
-     * Useful to show a loading spinner or disable a button.
-     *
-     * This also tracks new polls when the arguments have changed,
-     * but it does not track ongoing polls from either calling
-     * {@link poll} or using the `autopoll` argument.
-     */
-    isInitialPolling,
-  };
-}

package/src/pollers.ts

@@ -1,119 +0,0 @@
-import {
-  type Graffiti,
-  type JSONSchema,
-  type GraffitiObject,
-  type GraffitiObjectStreamReturn,
-  type GraffitiObjectStreamContinueEntry,
-  type GraffitiObjectStream,
-  type GraffitiObjectStreamContinue,
-  GraffitiErrorNotFound,
-} from "@graffiti-garden/api";
-
-export abstract class Poller<Schema extends JSONSchema> {
-  abstract poll(
-    onEntry: (
-      entry: GraffitiObjectStreamContinueEntry<Schema> | null | "clear",
-    ) => void,
-  ): Promise<void>;
-  abstract clear(): void;
-}
-
-/**
- * Polls for a single object and calls onValue with the result.
- */
-export class GetPoller<Schema extends JSONSchema> implements Poller<Schema> {
-  constructor(readonly getter: () => Promise<GraffitiObject<Schema>>) {}
-
-  poll: Poller<Schema>["poll"] = async (onEntry) => {
-    let object: GraffitiObject<Schema>;
-    const myGetter = this.getter;
-    try {
-      object = await myGetter();
-    } catch (e) {
-      if (this.getter === myGetter) {
-        onEntry(null);
-      }
-      return;
-    }
-    if (this.getter === myGetter) {
-      onEntry({ object });
-    }
-  };
-
-  clear() {}
-}
-
-/**
- * Polls for multiple objects and calls `onObject` with the result.
- * If `poll` is called multiple times, it doesn't poll the results
- * entirely from scratch, but instead only polls the new results.
- */
-export class StreamPoller<Schema extends JSONSchema> implements Poller<Schema> {
-  iterator: GraffitiObjectStreamContinue<Schema> | undefined;
-  continue: (() => GraffitiObjectStreamContinue<Schema>) | undefined;
-
-  constructor(readonly streamFactory: () => GraffitiObjectStream<Schema>) {}
-
-  clear() {
-    if (this.iterator) {
-      const iterator = this.iterator;
-      this.iterator.return({
-        continue: () => iterator,
-        cursor: "",
-      });
-    }
-    this.iterator = undefined;
-    this.continue = undefined;
-  }
-
-  poll: Poller<Schema>["poll"] = async (onEntry) => {
-    if (!this.iterator) {
-      if (this.continue) {
-        try {
-          this.iterator = this.continue();
-        } catch (e) {
-          // The cursor has expired, we need to start from scratch.
-          if (e instanceof GraffitiErrorNotFound) {
-            onEntry("clear");
-            this.iterator = this.streamFactory();
-          } else {
-            throw e;
-          }
-        }
-      } else {
-        this.iterator = this.streamFactory();
-      }
-    }
-
-    while (true) {
-      // Check if the iterator has been cancelled.
-      if (!this.iterator) {
-        break;
-      }
-
-      const myIterator: GraffitiObjectStreamContinue<Schema> = this.iterator;
-
-      const result = await myIterator.next();
-
-      // Check again if it was cancelled.
-      if (myIterator !== this.iterator) {
-        continue;
-      }
-
-      if (result.done) {
-        if (result.value) {
-          this.iterator = undefined;
-          this.continue = result.value.continue;
-        }
-        break;
-      }
-
-      if (result.value.error) {
-        console.error(result.value.error);
-        continue;
-      }
-
-      onEntry(result.value);
-    }
-  };
-}