jazz-vue 0.8.6

package/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright 2024, Garden Computing, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# `jazz-react`
+
+React bindings for Jazz (see [jazz.tools](https://jazz.tools)), a framework for distributed state.

package/dist/ProgressiveImg.vue.d.ts

@@ -0,0 +1,27 @@
+import { ImageDefinition } from 'jazz-tools';
+declare function __VLS_template(): {
+    slots: {
+        default?(_: {
+            src: string | undefined;
+            res: `${number}x${number}` | "placeholder" | undefined;
+            originalSize: readonly [number, number] | undefined;
+        }): any;
+    };
+    refs: {};
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<{
+    image: ImageDefinition | null | undefined;
+    maxWidth?: number;
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+    image: ImageDefinition | null | undefined;
+    maxWidth?: number;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/auth/DemoAuthBasicUI.vue.d.ts

@@ -0,0 +1,9 @@
+import { DemoAuthState } from './useDemoAuth.js';
+declare const _default: import('vue').DefineComponent<{
+    appName: string;
+    state: DemoAuthState;
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+    appName: string;
+    state: DemoAuthState;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/auth/useDemoAuth.d.ts

@@ -0,0 +1,56 @@
+import { AgentSecret } from 'cojson';
+import { BrowserDemoAuth } from 'jazz-browser';
+import { Account, ID } from 'jazz-tools';
+export type DemoAuthState = ({
+    state: "uninitialized";
+} | {
+    state: "loading";
+} | {
+    state: "ready";
+    existingUsers: string[];
+    signUp: (username: string) => void;
+    logInAs: (existingUser: string) => void;
+} | {
+    state: "signedIn";
+    logOut: () => void;
+}) & {
+    errors: string[];
+};
+/** @category Auth Providers */
+export declare function useDemoAuth({ seedAccounts, }?: {
+    seedAccounts?: {
+        [name: string]: {
+            accountID: ID<Account>;
+            accountSecret: AgentSecret;
+        };
+    };
+}): {
+    authMethod: import('vue').Ref<{
+        driver: {
+            onReady: (next: {
+                signUp: (username: string) => Promise<void>;
+                existingUsers: string[];
+                logInAs: (existingUser: string) => Promise<void>;
+            }) => void;
+            onSignedIn: (next: {
+                logOut: () => void;
+            }) => void;
+            onError: (error: string | Error) => void;
+        };
+        start: () => Promise<import('jazz-tools').AuthResult>;
+    }, BrowserDemoAuth | {
+        driver: {
+            onReady: (next: {
+                signUp: (username: string) => Promise<void>;
+                existingUsers: string[];
+                logInAs: (existingUser: string) => Promise<void>;
+            }) => void;
+            onSignedIn: (next: {
+                logOut: () => void;
+            }) => void;
+            onError: (error: string | Error) => void;
+        };
+        start: () => Promise<import('jazz-tools').AuthResult>;
+    }>;
+    state: import('vue').Reactive<DemoAuthState>;
+};

package/dist/createJazzVueApp.d.ts

@@ -0,0 +1,29 @@
+import { Account, AnonymousJazzAgent, CoValue, CoValueClass, DeeplyLoaded, DepthsIn, ID } from 'jazz-tools';
+import { Component, ComputedRef, Ref } from 'vue';
+export declare const logoutHandler: Ref<(() => void) | undefined, (() => void) | undefined>;
+export interface JazzVueApp<Acc extends Account> {
+    JazzProvider: Component;
+    useAccount(): {
+        me: ComputedRef<Acc>;
+        logOut: () => void;
+    };
+    useAccount<D extends DepthsIn<Acc>>(depth: D): {
+        me: ComputedRef<DeeplyLoaded<Acc, D> | undefined>;
+        logOut: () => void;
+    };
+    useAccountOrGuest(): {
+        me: ComputedRef<Acc | AnonymousJazzAgent>;
+    };
+    useAccountOrGuest<D extends DepthsIn<Acc>>(depth: D): {
+        me: ComputedRef<DeeplyLoaded<Acc, D> | undefined | AnonymousJazzAgent>;
+    };
+    useCoState<V extends CoValue, D>(Schema: CoValueClass<V>, id: ID<V> | undefined, depth?: D & DepthsIn<V>): Ref<DeeplyLoaded<V, D> | undefined>;
+    useAcceptInvite<V extends CoValue>(args: {
+        invitedObjectSchema: CoValueClass<V>;
+        onAccept: (projectID: ID<V>) => void;
+        forValueHint?: string;
+    }): void;
+}
+export declare function createJazzVueApp<Acc extends Account>({ AccountSchema, }?: {
+    AccountSchema?: any;
+}): JazzVueApp<Acc>;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './createJazzVueApp.js';
+export * from './auth/useDemoAuth.js';
+export { default as DemoAuthBasicUI } from './auth/DemoAuthBasicUI.vue';
+export { default as ProgressiveImg } from './ProgressiveImg.vue';

package/dist/index.js

@@ -0,0 +1,361 @@
+import { createJazzBrowserContext as D, consumeInviteLinkFromWindowLocation as _, BrowserDemoAuth as B } from "jazz-browser";
+import { Account as j, subscribeToCoValue as T } from "jazz-tools";
+import { ref as y, defineComponent as R, provide as V, onMounted as P, watch as A, onUnmounted as I, computed as v, toRaw as b, shallowRef as M, inject as N, reactive as $, openBlock as g, createElementBlock as f, normalizeStyle as w, Fragment as k, createElementVNode as x, toDisplayString as C, renderList as E, withModifiers as F, withDirectives as G, vModelText as W, createCommentVNode as L, toRef as q, renderSlot as H, unref as J } from "vue";
+const S = y(), O = Symbol("JazzContext");
+function te({
+  AccountSchema: p = j
+} = {}) {
+  const i = R({
+    name: "JazzProvider",
+    props: {
+      auth: {
+        type: [String, Object],
+        required: !0
+      },
+      peer: {
+        type: String,
+        required: !0
+      },
+      storage: {
+        type: String,
+        default: void 0
+      }
+    },
+    setup(r, { slots: o }) {
+      const t = y(
+        void 0
+      ), n = y(0);
+      V(O, t);
+      const s = async () => {
+        var e, u;
+        t.value && ((u = (e = t.value).done) == null || u.call(e), t.value = void 0);
+        try {
+          const m = await D(
+            r.auth === "guest" ? { peer: r.peer, storage: r.storage } : {
+              AccountSchema: p,
+              auth: r.auth,
+              peer: r.peer,
+              storage: r.storage
+            }
+          );
+          t.value = {
+            ...m,
+            logOut: () => {
+              var z;
+              (z = S.value) == null || z.call(S), n.value += 1;
+            }
+          };
+        } catch (m) {
+          console.error("Error creating Jazz browser context:", m);
+        }
+      };
+      return P(() => {
+        s();
+      }), A(
+        () => n.value,
+        async () => {
+          await s();
+        }
+      ), I(() => {
+        var e, u;
+        t.value && ((u = (e = t.value).done) == null || u.call(e));
+      }), () => {
+        var e;
+        return t.value ? (e = o.default) == null ? void 0 : e.call(o) : null;
+      };
+    }
+  });
+  function l() {
+    const r = N(O);
+    if (!r)
+      throw new Error("useJazzContext must be used within a JazzProvider");
+    return r;
+  }
+  function a(r) {
+    const o = l();
+    if (!o.value)
+      throw new Error("useAccount must be used within a JazzProvider");
+    if (!("me" in o.value))
+      throw new Error(
+        "useAccount can't be used in a JazzProvider with auth === 'guest' - consider using useAccountOrGuest()"
+      );
+    const t = d(
+      o.value.me.constructor,
+      o.value.me.id,
+      r
+    );
+    return {
+      me: v(() => {
+        const n = r === void 0 ? t.value || b(o.value.me) : t.value;
+        return n && b(n);
+      }),
+      logOut: o.value.logOut
+    };
+  }
+  function c(r) {
+    const o = l();
+    if (!o.value)
+      throw new Error("useAccountOrGuest must be used within a JazzProvider");
+    const t = "me" in o.value ? o.value.me : void 0, n = d(
+      t == null ? void 0 : t.constructor,
+      t == null ? void 0 : t.id,
+      r
+    );
+    return "me" in o.value ? {
+      me: v(
+        () => r === void 0 ? n.value || b(o.value.me) : n.value
+      )
+    } : {
+      me: v(() => b(o.value.guest))
+    };
+  }
+  function d(r, o, t = []) {
+    const n = M(void 0), s = l();
+    if (!s.value)
+      throw new Error("useCoState must be used within a JazzProvider");
+    let e;
+    return A(
+      [() => o, () => s, () => r, () => t],
+      () => {
+        e && e(), o && (e = T(
+          r,
+          o,
+          "me" in s.value ? b(s.value.me) : b(s.value.guest),
+          t,
+          (m) => {
+            n.value = m;
+          }
+        ));
+      },
+      { immediate: !0 }
+    ), I(() => {
+      e && e();
+    }), v(() => n.value);
+  }
+  function h({
+    invitedObjectSchema: r,
+    onAccept: o,
+    forValueHint: t
+  }) {
+    const n = l();
+    if (!n.value)
+      throw new Error("useAcceptInvite must be used within a JazzProvider");
+    if (!("me" in n.value))
+      throw new Error(
+        "useAcceptInvite can't be used in a JazzProvider with auth === 'guest'."
+      );
+    const s = () => {
+      _({
+        as: b(n.value.me),
+        invitedObjectSchema: r,
+        forValueHint: t
+      }).then((u) => u && o(u.valueID)).catch((u) => {
+        console.error("Failed to accept invite", u);
+      });
+    };
+    P(() => {
+      s();
+    }), A(
+      () => o,
+      (e, u) => {
+        e !== u && s();
+      }
+    );
+  }
+  return {
+    JazzProvider: i,
+    useAccount: a,
+    useAccountOrGuest: c,
+    useCoState: d,
+    useAcceptInvite: h
+  };
+}
+function re({
+  seedAccounts: p
+} = {}) {
+  const i = $({
+    state: "loading",
+    errors: []
+  }), l = y(
+    new B(
+      {
+        onReady: ({ signUp: a, existingUsers: c, logInAs: d }) => {
+          i.state = "ready", i.signUp = a, i.existingUsers = c, i.logInAs = d, i.errors = [];
+        },
+        onSignedIn: ({ logOut: a }) => {
+          i.state = "signedIn", i.logOut = () => {
+            a(), i.state = "ready", i.errors = [];
+          }, i.errors = [], S.value = i.logOut;
+        },
+        onError: (a) => {
+          i.errors.push(a.toString());
+        }
+      },
+      p
+    )
+  );
+  return I(() => {
+    i.state === "signedIn" && (S.value = void 0);
+  }), { authMethod: l, state: i };
+}
+const K = { key: 0 }, Q = {
+  key: 0,
+  style: { display: "flex", "flex-direction": "column", gap: "0.5rem" }
+}, X = ["onClick", "aria-label"], oe = /* @__PURE__ */ R({
+  __name: "DemoAuthBasicUI",
+  props: {
+    appName: {},
+    state: {}
+  },
+  setup(p) {
+    const i = p, l = y(""), a = v(
+      () => window.matchMedia && window.matchMedia("(prefers-color-scheme: dark)").matches
+    ), c = v(() => ({
+      minHeight: "100vh",
+      display: "flex",
+      flexDirection: "column",
+      justifyContent: "center",
+      alignItems: "center",
+      width: "100%",
+      padding: "1rem",
+      maxWidth: "100vw",
+      gap: "2rem",
+      margin: "0",
+      ...a.value ? { background: "#000" } : {}
+    })), d = v(() => ({
+      border: a.value ? "2px solid #444" : "2px solid #ddd",
+      padding: "11px 8px",
+      borderRadius: "6px",
+      background: a.value ? "#000" : "#fff",
+      color: a.value ? "#fff" : "#000"
+    })), h = v(() => ({
+      padding: "13px 5px",
+      border: "none",
+      borderRadius: "6px",
+      cursor: "pointer",
+      background: a.value ? "#444" : "#ddd",
+      color: a.value ? "#fff" : "#000"
+    })), r = v(() => ({
+      background: a.value ? "#0d0d0d" : "#eee",
+      color: a.value ? "#fff" : "#000",
+      padding: "0.5rem",
+      border: "none",
+      borderRadius: "6px"
+    })), o = () => {
+      i.state.signUp(l.value), l.value = "";
+    }, t = (n) => {
+      i.state.logInAs(n);
+    };
+    return (n, s) => (g(), f("div", {
+      style: w(c.value)
+    }, [
+      n.state.state === "loading" ? (g(), f("div", K, "Loading...")) : n.state.state === "ready" ? (g(), f(k, { key: 1 }, [
+        x("h1", {
+          style: w({ color: a.value ? "#fff" : "#000", textAlign: "center" })
+        }, C(n.appName), 5),
+        (g(!0), f(k, null, E(n.state.errors, (e) => (g(), f("div", {
+          key: e,
+          style: { color: "red" }
+        }, C(e), 1))), 128)),
+        x("form", {
+          onSubmit: F(o, ["prevent"]),
+          style: { display: "flex", "flex-direction": "column", gap: "0.5rem" }
+        }, [
+          G(x("input", {
+            "onUpdate:modelValue": s[0] || (s[0] = (e) => l.value = e),
+            placeholder: "Display name",
+            autoComplete: "webauthn",
+            style: w(d.value)
+          }, null, 4), [
+            [W, l.value]
+          ]),
+          x("input", {
+            type: "submit",
+            value: "Sign up",
+            style: w(h.value)
+          }, null, 4)
+        ], 32),
+        n.state.existingUsers.length > 0 ? (g(), f("div", Q, [
+          x("p", {
+            style: w({
+              color: a.value ? "#e2e2e2" : "#000",
+              textAlign: "center",
+              paddingTop: "0.5rem",
+              borderTop: "1px solid",
+              borderColor: a.value ? "#111" : "#e2e2e2"
+            })
+          }, " Log in as ", 4),
+          (g(!0), f(k, null, E(n.state.existingUsers, (e) => (g(), f("button", {
+            key: e,
+            onClick: (u) => t(e),
+            type: "button",
+            "aria-label": `Log in as ${e}`,
+            style: w(r.value)
+          }, C(e), 13, X))), 128))
+        ])) : L("", !0)
+      ], 64)) : L("", !0)
+    ], 4));
+  }
+}), ne = /* @__PURE__ */ R({
+  __name: "ProgressiveImg",
+  props: {
+    image: {},
+    maxWidth: {}
+  },
+  setup(p) {
+    function i(c, d) {
+      const h = y({});
+      let r;
+      const o = A(
+        () => {
+          var t;
+          return [(t = c.value) == null ? void 0 : t.id, d];
+        },
+        () => {
+          let t;
+          return c.value ? c.value.subscribe({}, (s) => {
+            var u, m;
+            const e = s == null ? void 0 : s.highestResAvailable({ maxWidth: d });
+            if (e) {
+              if (e.res !== t) {
+                t = e.res;
+                const z = e.stream.toBlob();
+                if (z) {
+                  const U = URL.createObjectURL(z);
+                  h.value = {
+                    src: U,
+                    res: e.res,
+                    originalSize: (u = c.value) == null ? void 0 : u.originalSize
+                  }, r && r(), r = () => {
+                    setTimeout(() => URL.revokeObjectURL(U), 200);
+                  };
+                }
+              }
+            } else
+              h.value = {
+                src: s == null ? void 0 : s.placeholderDataURL,
+                res: "placeholder",
+                originalSize: (m = c.value) == null ? void 0 : m.originalSize
+              };
+          }) : void 0;
+        }
+      );
+      return I(() => {
+        o(), r && r();
+      }), h;
+    }
+    const l = p, a = i(q(l, "image"), l.maxWidth);
+    return (c, d) => H(c.$slots, "default", {
+      src: J(a).src,
+      res: J(a).res,
+      originalSize: J(a).originalSize
+    });
+  }
+});
+export {
+  oe as DemoAuthBasicUI,
+  ne as ProgressiveImg,
+  te as createJazzVueApp,
+  S as logoutHandler,
+  re as useDemoAuth
+};

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "jazz-vue",
+  "version": "0.8.6",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "src/index.ts",
+  "license": "MIT",
+  "dependencies": {
+    "@scure/bip39": "^1.3.0",
+    "cojson": "0.8.16",
+    "jazz-browser": "0.8.16",
+    "jazz-tools": "0.8.16"
+  },
+  "devDependencies": {
+    "@vitejs/plugin-vue": "^5.1.4",
+    "typescript": "^5.3.3",
+    "vite": "^5.0.10",
+    "vite-plugin-dts": "^4.2.4",
+    "vue": "^3.5.11",
+    "vue-tsc": "^2.1.6"
+  },
+  "peerDependencies": {
+    "vue": "^3.5.11"
+  },
+  "scripts": {
+    "dev": "vite",
+    "format-and-lint": "biome check .",
+    "format-and-lint:fix": "biome check . --write",
+    "build": "rm -rf ./dist && vite build"
+  }
+}

package/src/ProgressiveImg.vue

@@ -0,0 +1,82 @@
+<script setup lang="ts">
+import type { ImageDefinition } from "jazz-tools";
+import { type Ref, onUnmounted, ref, toRef, watch } from "vue";
+
+interface ImageState {
+  src?: string;
+  res?: `${number}x${number}` | "placeholder";
+  originalSize?: readonly [number, number];
+}
+
+function useProgressiveImg(
+  image: Ref<ImageDefinition | null | undefined>,
+  maxWidth?: number,
+) {
+  const current = ref<ImageState>({});
+
+  let cleanup: (() => void) | undefined;
+  const unsubscribe = watch(
+    () => [image.value?.id, maxWidth],
+    () => {
+      let lastHighestRes: string | undefined;
+
+      if (!image.value) return;
+
+      const unsub = image.value.subscribe({}, (update) => {
+        const highestRes = update?.highestResAvailable({ maxWidth });
+
+        if (highestRes) {
+          if (highestRes.res !== lastHighestRes) {
+            lastHighestRes = highestRes.res;
+            const blob = highestRes.stream.toBlob();
+
+            if (blob) {
+              const blobURI = URL.createObjectURL(blob);
+              current.value = {
+                src: blobURI,
+                res: highestRes.res,
+                originalSize: image.value?.originalSize,
+              };
+
+              if (cleanup) cleanup();
+              cleanup = () => {
+                setTimeout(() => URL.revokeObjectURL(blobURI), 200);
+              };
+            }
+          }
+        } else {
+          current.value = {
+            src: update?.placeholderDataURL,
+            res: "placeholder",
+            originalSize: image.value?.originalSize,
+          };
+        }
+      });
+
+      return unsub;
+    },
+  );
+
+  onUnmounted(() => {
+    unsubscribe();
+    if (cleanup) cleanup();
+  });
+
+  return current;
+}
+
+const props = defineProps<{
+  image: ImageDefinition | null | undefined;
+  maxWidth?: number;
+}>();
+
+const current = useProgressiveImg(toRef(props, "image"), props.maxWidth);
+</script>
+
+<template>
+  <slot
+    :src="current.src"
+    :res="current.res"
+    :original-size="current.originalSize"
+  />
+</template>