community-jazz-vue 0.15.4

package/src/tests/useIsAuthenticated.test.ts

@@ -0,0 +1,35 @@
+// @vitest-environment happy-dom
+
+import { AuthSecretStorage, InMemoryKVStore, KvStoreContext } from "jazz-tools";
+import { createJazzTestAccount } from "jazz-tools/testing";
+import { beforeEach, describe, expect, it } from "vitest";
+import { useIsAuthenticated } from "../auth/useIsAuthenticated.js";
+import { withJazzTestSetup } from "./testUtils.js";
+
+// Initialize KV store for tests
+KvStoreContext.getInstance().initialize(new InMemoryKVStore());
+
+describe("useIsAuthenticated", () => {
+  let authSecretStorage: AuthSecretStorage;
+
+  beforeEach(async () => {
+    // Clear storage and create new instance for each test
+    KvStoreContext.getInstance().getStorage().clearAll();
+    authSecretStorage = new AuthSecretStorage();
+    await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+    });
+  });
+
+  it("should return false when no credentials exist", () => {
+    const [result] = withJazzTestSetup(() => useIsAuthenticated());
+    expect(result.value).toBe(false);
+  });
+
+  it("should return true when valid credentials exist", async () => {
+    const [result] = withJazzTestSetup(() => useIsAuthenticated(), {
+      isAuthenticated: true,
+    });
+    expect(result.value).toBe(true);
+  });
+});

package/src/tests/usePassphraseAuth.test.ts

@@ -0,0 +1,95 @@
+// @vitest-environment happy-dom
+
+import { mnemonicToEntropy } from "@scure/bip39";
+import { AuthSecretStorage, KvStoreContext } from "jazz-tools";
+import { createJazzTestAccount, setupJazzTestSync } from "jazz-tools/testing";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { usePassphraseAuth } from "../index.js";
+import { testWordlist } from "./fixtures.js";
+import { waitFor, withJazzTestSetup } from "./testUtils.js";
+
+describe("usePassphraseAuth", () => {
+  beforeEach(async () => {
+    await setupJazzTestSync();
+    await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+    });
+  });
+
+  afterEach(() => {
+    KvStoreContext.getInstance().getStorage().clearAll();
+  });
+
+  it("should show anonymous in state with non-authenticated account", async () => {
+    const [result] = withJazzTestSetup(
+      () => usePassphraseAuth({ wordlist: testWordlist }),
+      {
+        isAuthenticated: false,
+      },
+    );
+
+    expect(result.value.state).toBe("anonymous");
+  });
+
+  it("should show signed in state with authenticated account", async () => {
+    const [result] = withJazzTestSetup(
+      () => usePassphraseAuth({ wordlist: testWordlist }),
+      {
+        isAuthenticated: true,
+      },
+    );
+
+    expect(result.value.state).toBe("signedIn");
+  });
+
+  it("should sign up with the current credentials", async () => {
+    const [result] = withJazzTestSetup(() =>
+      usePassphraseAuth({ wordlist: testWordlist }),
+    );
+
+    const authSecretStorage = new AuthSecretStorage();
+    const credentialsBefore = await authSecretStorage.get();
+
+    const passphrase = await result.value.signUp();
+
+    expect(result.value.state).toBe("signedIn");
+    expect(await authSecretStorage.get()).toEqual({
+      ...credentialsBefore,
+      provider: "passphrase",
+    });
+    expect(mnemonicToEntropy(passphrase, testWordlist)).toEqual(
+      credentialsBefore?.secretSeed,
+    );
+  });
+
+  it("should log in with the previous passphrase", async () => {
+    const [result] = withJazzTestSetup(() =>
+      usePassphraseAuth({ wordlist: testWordlist }),
+    );
+
+    const authSecretStorage = new AuthSecretStorage();
+    const credentialsBefore = await authSecretStorage.get();
+
+    const passphrase = await result.value.signUp();
+
+    await result.value.logIn(passphrase);
+
+    expect(result.value.state).toBe("signedIn");
+    expect(await authSecretStorage.get()).toMatchObject({
+      ...credentialsBefore,
+      provider: "passphrase",
+    });
+  });
+
+  it("should return the current account passphrase", async () => {
+    const [result] = withJazzTestSetup(() =>
+      usePassphraseAuth({ wordlist: testWordlist }),
+    );
+
+    await waitFor(() => result.value.passphrase !== "");
+
+    const passphrase = result.value.passphrase;
+
+    expect(await result.value.signUp()).toBe(passphrase);
+  });
+});

package/src/utils/contextManager.ts

@@ -0,0 +1,31 @@
+import type { Account, JazzContextManager } from "jazz-tools";
+
+// This was copied from react-core/utils.ts, so the changes from one does not impact the changes in another
+// But this is sub-par and should be merged since it's portable for now.
+
+export function getCurrentAccountFromContextManager<Acc extends Account>(
+  contextManager: JazzContextManager<Acc, any>,
+) {
+  const context = contextManager.getCurrentValue();
+
+  if (!context) {
+    throw new Error("No context found");
+  }
+
+  return "me" in context ? context.me : context.guest;
+}
+
+export function subscribeToContextManager<Acc extends Account>(
+  contextManager: JazzContextManager<Acc, any>,
+  callback: () => () => void,
+) {
+  let unsub = () => {};
+
+  const handler = () => {
+    unsub();
+    unsub = callback();
+  };
+
+  handler();
+  return contextManager.subscribe(handler);
+}

package/src/vite-env.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="vite/client" />
+
+declare module "*.vue" {
+  import type { DefineComponent } from "vue";
+  const component: DefineComponent<{}, {}, any>;
+  export default component;
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "lib": ["ESNext", "DOM"],
+    "skipLibCheck": true,
+    "moduleResolution": "bundler",
+    "moduleDetection": "force",
+    "jsx": "preserve",
+    "jsxImportSource": "vue",
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "noUncheckedIndexedAccess": true,
+    "esModuleInterop": true,
+    "declaration": true,
+    "isolatedModules": true
+  },
+  "include": ["src/**/*.ts", "src/**/*.tsx", "src/**/*.vue"],
+  "exclude": ["node_modules", "dist", "vite.config.ts"]
+}

package/vite.config.ts

@@ -0,0 +1,31 @@
+import path from "node:path";
+import vue from "@vitejs/plugin-vue";
+import vueJsx from "@vitejs/plugin-vue-jsx";
+import depsExternal from "rollup-plugin-node-externals";
+import { defineConfig } from "vite";
+import dts from "vite-plugin-dts";
+
+export default defineConfig({
+  plugins: [
+    vue(),
+    vueJsx(),
+    dts({ include: ["src/**/*.ts", "src/**/*.vue"], outDir: "dist" }),
+    depsExternal(),
+  ],
+  build: {
+    lib: {
+      entry: {
+        index: path.resolve(__dirname, "src/index.ts"),
+        testing: path.resolve(__dirname, "src/testing.ts"),
+      },
+      name: "JazzVue",
+      formats: ["es"],
+      fileName: (_, entryName) => `${entryName}.js`,
+    },
+    rollupOptions: {
+      external: ["vue"],
+    },
+    sourcemap: true,
+    minify: false,
+  },
+});