@gryt/core 0.7.0 → 0.9.0

package/dist/index.d.ts

@@ -7,3 +7,6 @@ export { inviteLink, isPublicHost, normalizeCode, normalizeHost, parseServerInpu
 export { NAME_POOL, pickRandomName } from "./profile/randomName.js";
 export { cellState, CUSTOM_VALUE, describeRules, EVERYONE_VALUE, indexRules, nextCellState, scopeChoiceFromValue, scopeChoiceValue, scopeOptions, scopeSetPayload, withCell, type CellState, type ChannelRule, type RuleEffect, type ScopeChoice, } from "./permissions/channelRules.js";
 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

@@ -9,3 +9,6 @@ export { inviteLink, isPublicHost, normalizeCode, normalizeHost, parseServerInpu
 export { NAME_POOL, pickRandomName } from "./profile/randomName.js";
 export { cellState, CUSTOM_VALUE, describeRules, EVERYONE_VALUE, indexRules, nextCellState, scopeChoiceFromValue, scopeChoiceValue, scopeOptions, scopeSetPayload, withCell, } from "./permissions/channelRules.js";
 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/permissions/folderRules.d.ts

@@ -0,0 +1,10 @@
+import type { ChannelRule } from "./channelRules.js";
+/** "the X folder", or "its folder" when nothing is named. */
+export declare function folderPhrase(folderName: string | null): string;
+/** Shown once a channel has permissions of its own instead of following its folder. */
+export declare function folderFollowNote(folderName: string | null): string;
+/**
+ * The folder's half of `describeRules`: reading denied here hides the folder
+ * along with every channel in it that follows it.
+ */
+export declare function describeFolderRules(rules: ChannelRule[], roleNames: Map<string, string>): string;

package/dist/permissions/folderRules.js

@@ -0,0 +1,29 @@
+/** "the X folder", or "its folder" when nothing is named. */
+export function folderPhrase(folderName) {
+    return folderName ? `the ${folderName} folder` : "its folder";
+}
+/** Shown once a channel has permissions of its own instead of following its folder. */
+export function folderFollowNote(folderName) {
+    return `Has its own permissions instead of ${folderPhrase(folderName)}'s.`;
+}
+/**
+ * The folder's half of `describeRules`: reading denied here hides the folder
+ * along with every channel in it that follows it.
+ */
+export function describeFolderRules(rules, roleNames) {
+    if (rules.length === 0) {
+        return "Everyone on the server can see and use the channels in this folder.";
+    }
+    const hidden = rules
+        .filter((r) => r.permission === "read_messages" && r.effect === "deny")
+        .map((r) => roleNames.get(r.roleId) ?? r.roleId);
+    const others = rules.filter((r) => r.permission !== "read_messages").length;
+    if (hidden.length === 0) {
+        return `${others} change${others === 1 ? "" : "s"} to what roles can do in this folder's channels.`;
+    }
+    const list = hidden.length === 1
+        ? hidden[0]
+        : `${hidden.slice(0, -1).join(", ")} and ${hidden[hidden.length - 1]}`;
+    const rest = others > 0 ? `, and ${others} other change${others === 1 ? "" : "s"}` : "";
+    return `${list} won't see this folder or anything in it${rest}.`;
+}

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/dist/webrtc/senderStreamId.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The stream id for a role: the first one given on this connection, kept in place
+ * across a `replaceTrack` swap. With no connection, `streamId` is returned unchanged.
+ */
+export declare function senderStreamId<Role extends string>(pc: object | null | undefined, role: Role, streamId: string): string;

package/dist/webrtc/senderStreamId.js

@@ -0,0 +1,16 @@
+/** Keyed by connection, so a reconnect — a new connection object — starts over. */
+const byConnection = new WeakMap();
+/**
+ * The stream id for a role: the first one given on this connection, kept in place
+ * across a `replaceTrack` swap. With no connection, `streamId` is returned unchanged.
+ */
+export function senderStreamId(pc, role, streamId) {
+    if (!pc)
+        return streamId;
+    let ids = byConnection.get(pc);
+    if (!ids) {
+        ids = {};
+        byConnection.set(pc, ids);
+    }
+    return (ids[role] ??= streamId);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gryt/core",
-  "version": "0.7.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": {