@gryt/core 0.8.0 → 0.9.0

package/dist/index.d.ts

@@ -9,3 +9,4 @@ export { cellState, CUSTOM_VALUE, describeRules, EVERYONE_VALUE, indexRules, nex
 export { groupMembersByRole, OFFLINE_GROUP_KEY, UNGROUPED_GROUP_KEY, type GroupableMember, type GroupableRole, type MemberGroup, } from "./members/groups.js";
 export { senderStreamId } from "./webrtc/senderStreamId.js";
 export { describeFolderRules, folderFollowNote, folderPhrase, } from "./permissions/folderRules.js";
+export { agreementAt, createTermsGate, GUIDELINES_URL, TERMS_STORAGE_KEY, TERMS_URL, TERMS_VERSION, } from "./terms/termsAgreement.js";

package/dist/index.js

@@ -11,3 +11,4 @@ export { cellState, CUSTOM_VALUE, describeRules, EVERYONE_VALUE, indexRules, nex
 export { groupMembersByRole, OFFLINE_GROUP_KEY, UNGROUPED_GROUP_KEY, } from "./members/groups.js";
 export { senderStreamId } from "./webrtc/senderStreamId.js";
 export { describeFolderRules, folderFollowNote, folderPhrase, } from "./permissions/folderRules.js";
+export { agreementAt, createTermsGate, GUIDELINES_URL, TERMS_STORAGE_KEY, TERMS_URL, TERMS_VERSION, } from "./terms/termsAgreement.js";

package/dist/terms/termsAgreement.d.ts

@@ -0,0 +1,28 @@
+export declare const TERMS_URL = "https://gryt.chat/terms";
+export declare const GUIDELINES_URL = "https://gryt.chat/community-guidelines";
+export declare const TERMS_VERSION = "2026-09-03";
+export declare const TERMS_STORAGE_KEY = "gryt.termsAgreement";
+export interface TermsAgreement {
+    version: string;
+    agreedAt: string;
+}
+export interface TermsStorage {
+    read: () => string | null | Promise<string | null>;
+    write: (value: string) => void | Promise<void>;
+}
+/** What storage held, or null when nothing in it is an agreement. */
+export declare function parseAgreement(raw: string | null | undefined): TermsAgreement | null;
+/** Agreeing to newer terms covers older ones, so a downgrade doesn't ask twice. */
+export declare function coversTerms(agreement: TermsAgreement | null, version?: string): boolean;
+export declare function agreementAt(now: Date, version?: string): TermsAgreement;
+export interface TermsGate {
+    /** Runs `post` once this device has agreed: now, or after the person presses Agree. */
+    postAfterAgreeing: (post: () => void) => void;
+    agree: () => void;
+    decline: () => void;
+    /** Reads storage ahead of the first post, so that one doesn't wait for it. */
+    load: () => void;
+    asking: () => boolean;
+    subscribe: (listener: () => void) => () => void;
+}
+export declare function createTermsGate(storage: TermsStorage, version?: string, now?: () => Date): TermsGate;

package/dist/terms/termsAgreement.js

@@ -0,0 +1,125 @@
+export const TERMS_URL = "https://gryt.chat/terms";
+export const GUIDELINES_URL = "https://gryt.chat/community-guidelines";
+/* The newer of the two pages' "Last updated" dates. Moving it asks everybody again,
+   so move it when a change to either page should. */
+export const TERMS_VERSION = "2026-09-03";
+export const TERMS_STORAGE_KEY = "gryt.termsAgreement";
+const DAY = /^\d{4}-\d{2}-\d{2}$/;
+/** What storage held, or null when nothing in it is an agreement. */
+export function parseAgreement(raw) {
+    if (!raw)
+        return null;
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    if (!value || typeof value !== "object")
+        return null;
+    const { version, agreedAt } = value;
+    if (typeof version !== "string" || !DAY.test(version))
+        return null;
+    if (typeof agreedAt !== "string")
+        return null;
+    return { version, agreedAt };
+}
+/** Agreeing to newer terms covers older ones, so a downgrade doesn't ask twice. */
+export function coversTerms(agreement, version = TERMS_VERSION) {
+    return agreement !== null && agreement.version >= version;
+}
+export function agreementAt(now, version = TERMS_VERSION) {
+    return { version, agreedAt: now.toISOString() };
+}
+export function createTermsGate(storage, version = TERMS_VERSION, now = () => new Date()) {
+    let agreed = false;
+    let queued = null;
+    let asked = null;
+    let reading = false;
+    const listeners = new Set();
+    const emit = () => {
+        for (const listener of listeners)
+            listener();
+    };
+    const settle = (raw) => {
+        if (coversTerms(parseAgreement(raw), version))
+            agreed = true;
+    };
+    const flush = () => {
+        const post = queued;
+        queued = null;
+        if (!post)
+            return;
+        if (agreed) {
+            post();
+            return;
+        }
+        asked = post;
+        emit();
+    };
+    // One read at a time, and only the newest post waits on it: two taps must not send twice.
+    const refresh = () => {
+        if (reading)
+            return;
+        let raw;
+        try {
+            raw = storage.read();
+        }
+        catch {
+            raw = null;
+        }
+        if (raw === null || typeof raw === "string") {
+            settle(raw);
+            flush();
+            return;
+        }
+        reading = true;
+        raw
+            .then(settle, () => undefined)
+            .then(() => {
+            reading = false;
+            flush();
+        });
+    };
+    return {
+        postAfterAgreeing(post) {
+            if (agreed) {
+                post();
+                return;
+            }
+            queued = post;
+            refresh();
+        },
+        agree() {
+            agreed = true;
+            const post = asked;
+            asked = null;
+            emit();
+            try {
+                void Promise.resolve(storage.write(JSON.stringify(agreementAt(now(), version)))).catch(() => undefined);
+            }
+            catch {
+                // Holds until the app restarts, and then it asks again.
+            }
+            post?.();
+        },
+        decline() {
+            if (!asked)
+                return;
+            asked = null;
+            emit();
+        },
+        load() {
+            if (!agreed)
+                refresh();
+        },
+        asking: () => asked !== null,
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gryt/core",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Gryt's shared application logic: one implementation of the things the desktop and mobile apps both do.",
   "license": "AGPL-3.0-only",
   "repository": {