wenay-common2 1.0.73 → 1.0.75

package/lib/Common/peer/peer-call.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callPortOf = callPortOf;
+exports.createCallManager = createCallManager;
+const Listen_1 = require("../events/Listen");
+function callPortOf(remote) {
+    return {
+        send: env => remote.signal.send(env),
+        signals: { on: cb => remote.signal.signals.on(cb) },
+    };
+}
+function createCallManager(deps) {
+    const { port, self, ringTimeoutMs = 30_000, incoming } = deps;
+    const [emitRing, rings] = (0, Listen_1.listen)();
+    const calls = new Map();
+    let n = 0;
+    const callScope = Date.now().toString(36) + Math.random().toString(36).slice(2, 10);
+    let evaluatingIncoming = 0;
+    let closed = false;
+    function makeCall(pair, other, direction, meta) {
+        let state = 'ringing';
+        let reason = null;
+        const [emitChange, changed] = (0, Listen_1.listen)();
+        let resolveEnded;
+        const ended = new Promise(r => { resolveEnded = r; });
+        const ringTimer = setTimeout(function onRingTimeout() { finish('timeout', direction == 'out'); }, ringTimeoutMs);
+        function send(type, why) {
+            void Promise.resolve(port.send({ type, pair, from: self, to: other, reason: why })).catch(swallowSendError);
+        }
+        function finish(why, notify, notifyAs = 'hangup') {
+            if (state == 'ended')
+                return;
+            state = 'ended';
+            reason = why;
+            clearTimeout(ringTimer);
+            calls.delete(pair);
+            if (notify)
+                send(notifyAs, why);
+            emitChange('ended');
+            changed.close();
+            resolveEnded(why);
+        }
+        function activate() {
+            if (state != 'ringing')
+                return;
+            state = 'active';
+            clearTimeout(ringTimer);
+            emitChange('active');
+        }
+        const handle = {
+            id: pair,
+            peer: other,
+            direction,
+            meta,
+            state: () => state,
+            reason: () => reason,
+            changed,
+            ended,
+            accept() {
+                if (direction != 'in' || state != 'ringing')
+                    return;
+                send('accept');
+                activate();
+            },
+            decline(why = 'declined') {
+                if (direction != 'in' || state != 'ringing')
+                    return;
+                finish(why, true, 'decline');
+            },
+            hangup() {
+                finish(state == 'ringing' && direction == 'out' ? 'canceled' : 'hangup', true);
+            },
+        };
+        return { handle, activate, finish };
+    }
+    function swallowSendError() { }
+    function hasLiveCall() {
+        for (const c of calls.values())
+            if (c.handle.state() != 'ended')
+                return true;
+        return false;
+    }
+    function call(other, meta) {
+        if (closed)
+            throw new Error('call manager is closed');
+        const pair = 'call:' + self + ':' + callScope + ':' + (++n);
+        const made = makeCall(pair, other, 'out', meta);
+        calls.set(pair, made);
+        Promise.resolve(port.send({ type: 'ring', pair, from: self, to: other, session: meta }))
+            .then(function onRingVerdict(accepted) {
+            if (accepted == false)
+                made.finish('offline', false);
+        }, function onRingSendError() { made.finish('offline', false); });
+        return made.handle;
+    }
+    async function onRing(env) {
+        if (calls.has(env.pair))
+            return;
+        evaluatingIncoming++;
+        const gate = incoming ?? function defaultBusyGate() {
+            return evaluatingIncoming == 1 && !hasLiveCall();
+        };
+        let allowed = false;
+        try {
+            allowed = !!(await gate({ peer: env.from, meta: env.session }));
+        }
+        catch {
+            allowed = false;
+        }
+        finally {
+            evaluatingIncoming--;
+        }
+        if (closed)
+            return;
+        if (!allowed) {
+            void Promise.resolve(port.send({ type: 'decline', pair: env.pair, from: self, to: env.from, reason: 'busy' })).catch(swallowSendError);
+            return;
+        }
+        const made = makeCall(env.pair, env.from, 'in', env.session);
+        calls.set(env.pair, made);
+        emitRing(made.handle);
+    }
+    const readyProbe = 'call-ready:' + self;
+    let resolveReady;
+    const ready = new Promise(r => { resolveReady = r; });
+    const offSignals = port.signals.on(function onCallSignal(env) {
+        if (closed || env == null || env.to != self)
+            return;
+        if (env.pair == readyProbe) {
+            resolveReady();
+            return;
+        }
+        if (env.type == 'ring') {
+            void onRing(env);
+            return;
+        }
+        const live = calls.get(env.pair);
+        if (!live)
+            return;
+        if (env.type == 'accept') {
+            live.activate();
+            return;
+        }
+        if (env.type == 'decline') {
+            live.finish(env.reason ?? 'declined', false);
+            return;
+        }
+        if (env.type == 'hangup') {
+            live.finish(live.handle.state() == 'ringing' ? 'canceled' : 'hangup', false);
+        }
+    });
+    Promise.resolve(port.send({ type: 'close', pair: readyProbe, from: self, to: self }))
+        .then(function onProbeVerdict(v) { if (v == false)
+        resolveReady(); }, function onProbeError() { resolveReady(); });
+    return {
+        ready,
+        call,
+        rings,
+        active: () => Array.from(calls.values()).map(c => c.handle).find(h => h.state() == 'active') ?? null,
+        close() {
+            if (closed)
+                return;
+            closed = true;
+            if (typeof offSignals == 'function')
+                offSignals();
+            else
+                offSignals?.off?.();
+            for (const c of Array.from(calls.values()))
+                c.finish('closed', true);
+            rings.close();
+        },
+    };
+}

package/lib/Common/peer/peer-client.d.ts

@@ -14,6 +14,15 @@ export type PeerRemote = {
     peers: Record<string, ReplayRemote<[StorePatch]> & {
         seq?: () => number | Promise<number>;
     }>;
+    presence?: {
+        list: () => Promise<string[]> | string[];
+        changes: {
+            on: (cb: (change: {
+                account: string;
+                online: boolean;
+            }) => void) => any;
+        };
+    };
 };
 export type tPublishRepair<J extends tRelayGap = 'resume'> = J extends 'sacred' ? 'tail' : 'tail' | 'keyframe';
 export type PeerClientDeps<T extends object, J extends tRelayGap = 'resume'> = {

package/lib/Common/peer/peer-host.d.ts

@@ -2,20 +2,29 @@ import { StorePatch } from '../Observe/store';
 import { ReplayRemote } from '../events/replay-wire';
 import { SignalEnvelope } from '../events/route-signal-webrtc';
 import { PatchEnvelope, tRelayGap } from './peer-relay';
+export type PresenceChange = {
+    account: string;
+    online: boolean;
+};
 export type PeerHostDeps = {
     authorize?: (env: SignalEnvelope) => boolean | Promise<boolean>;
     history?: number;
     gap?: tRelayGap;
+    accounts?: (account: string) => boolean;
 };
 export declare function createPeerHost(deps?: PeerHostDeps): {
     connection: (account: string) => {
         fragment: {
             signal: {
                 send: (env: SignalEnvelope) => Promise<boolean>;
-                signals: import("../..").ListenApi<[SignalEnvelope]>;
+                signals: import("../events/Listen").ListenApi<[SignalEnvelope]>;
             };
             publish: (env: PatchEnvelope) => import("./peer-relay").RelayPushResult;
             peers: Record<string, ReplayRemote<[StorePatch]>>;
+            presence: {
+                list: () => string[];
+                changes: import("../events/Listen").ListenApi<[PresenceChange]>;
+            };
         };
         close: () => void;
     };
@@ -30,6 +39,10 @@ export declare function createPeerHost(deps?: PeerHostDeps): {
         close: () => void;
     };
     accounts: () => string[];
+    presence: {
+        list: () => string[];
+        changes: import("../events/Listen").ListenApi<[PresenceChange]>;
+    };
     revoke: (pair: string, accounts: string[], reason?: string) => void;
     close(): void;
 };

package/lib/Common/peer/peer-host.js

@@ -2,41 +2,85 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createPeerHost = createPeerHost;
 const rpc_dynamic_1 = require("../rcp/rpc-dynamic");
+const Listen_1 = require("../events/Listen");
 const route_signal_webrtc_1 = require("../events/route-signal-webrtc");
 const peer_relay_1 = require("./peer-relay");
 function createPeerHost(deps = {}) {
-    const { authorize, history, gap } = deps;
+    const { authorize, history, gap, accounts: accountAllowed } = deps;
     const hub = (0, route_signal_webrtc_1.createSignalHub)({ authorize });
     const relays = new Map();
-    const peersView = (0, rpc_dynamic_1.noStrict)({});
+    const peersMap = {};
+    const peersView = (0, rpc_dynamic_1.noStrict)(new Proxy(peersMap, {
+        has(_t, k) { return typeof k == 'string' && (!accountAllowed || accountAllowed(k)); },
+        get(t, k) {
+            if (typeof k != 'string')
+                return t[k];
+            if (accountAllowed && !accountAllowed(k))
+                return undefined;
+            return ensureRelay(k).remote;
+        },
+    }));
+    const online = new Map();
+    const [emitPresence, presenceChanges] = (0, Listen_1.listen)();
+    const presence = {
+        list: () => Array.from(online.keys()),
+        changes: presenceChanges,
+    };
+    function presenceJoin(account) {
+        const n = (online.get(account) ?? 0) + 1;
+        online.set(account, n);
+        if (n == 1)
+            emitPresence({ account, online: true });
+    }
+    function presenceLeave(account) {
+        const n = (online.get(account) ?? 0) - 1;
+        if (n > 0) {
+            online.set(account, n);
+            return;
+        }
+        online.delete(account);
+        emitPresence({ account, online: false });
+    }
     function ensureRelay(account) {
         let relay = relays.get(account);
         if (!relay) {
             relay = (0, peer_relay_1.createPatchRelayJournal)({ history, gap });
             relays.set(account, relay);
-            peersView[account] = relay.remote;
+            peersMap[account] = relay.remote;
         }
         return relay;
     }
     function connection(account) {
         const port = hub.register(account);
         const mine = ensureRelay(account);
+        presenceJoin(account);
+        let closed = false;
         return {
             fragment: {
                 signal: { send: port.send, signals: port.signals },
                 publish: (env) => mine.push(env),
                 peers: peersView,
+                presence,
+            },
+            close: function closeConnection() {
+                if (closed)
+                    return;
+                closed = true;
+                port.close();
+                presenceLeave(account);
             },
-            close: () => port.close(),
         };
     }
     return {
         connection,
         relay: ensureRelay,
         accounts: () => Array.from(relays.keys()),
+        presence,
         revoke: hub.revoke,
         close() {
             hub.close();
+            presenceChanges.close();
+            online.clear();
             for (const relay of relays.values())
                 relay.close();
             relays.clear();

package/lib/Common/peer/peer-index.d.ts

@@ -1,3 +1,5 @@
 export * from './peer-relay';
 export * from './peer-host';
 export * from './peer-client';
+export * from './peer-media-relay';
+export * from './peer-call';

package/lib/Common/peer/peer-index.js

@@ -17,3 +17,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./peer-relay"), exports);
 __exportStar(require("./peer-host"), exports);
 __exportStar(require("./peer-client"), exports);
+__exportStar(require("./peer-media-relay"), exports);
+__exportStar(require("./peer-call"), exports);

package/lib/Common/peer/peer-media-relay.d.ts

@@ -0,0 +1,22 @@
+import { ListenReplayApi } from '../events/replay-listen';
+export type tMediaRelayKind = 'video' | 'audio';
+export type tCanWatch = (watcher: string, owner: string, line: string) => boolean;
+export type MediaRelayDeps = {
+    lines: Record<string, tMediaRelayKind>;
+    videoHistory?: number;
+    audioHistory?: number;
+    canWatch?: tCanWatch;
+};
+type tMediaFrame = [unknown, number];
+type tRelayLine = ListenReplayApi<tMediaFrame>;
+export declare function createMediaRelay(deps: MediaRelayDeps): {
+    publishOf: (account: string) => (line: string, frame: unknown, sentAt: number) => void;
+    watch: Record<string, Record<string, tRelayLine>>;
+    watchOf: (watcher: string) => Record<string, Record<string, tRelayLine>>;
+    lines: (account: string) => Record<string, tRelayLine>;
+    accounts: () => string[];
+    dropAccount: (account: string) => void;
+    close(): void;
+};
+export type MediaRelay = ReturnType<typeof createMediaRelay>;
+export {};

package/lib/Common/peer/peer-media-relay.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMediaRelay = createMediaRelay;
+const replay_listen_1 = require("../events/replay-listen");
+const rpc_dynamic_1 = require("../rcp/rpc-dynamic");
+function createMediaRelay(deps) {
+    const { lines, videoHistory = 8, audioHistory = 64, canWatch } = deps;
+    const accounts = new Map();
+    const watch = (0, rpc_dynamic_1.noStrict)({});
+    function makeLine(kind) {
+        return kind == 'video'
+            ? (0, replay_listen_1.replayListen)({
+                history: videoHistory, current: 'last',
+                frame: function lastFrameOnly(tail) { return tail.length ? [tail[tail.length - 1]] : []; },
+            })
+            : (0, replay_listen_1.replayListen)({ history: audioHistory });
+    }
+    function linesOf(account) {
+        let entry = accounts.get(account);
+        if (!entry) {
+            entry = { emits: {}, view: (0, rpc_dynamic_1.noStrict)({}) };
+            for (const name of Object.keys(lines)) {
+                const [emit, api] = makeLine(lines[name]);
+                entry.emits[name] = emit;
+                entry.view[name] = api;
+            }
+            accounts.set(account, entry);
+            watch[account] = entry.view;
+        }
+        return entry;
+    }
+    function publishOf(account) {
+        linesOf(account);
+        return function publish(line, frame, sentAt) {
+            linesOf(account).emits[line]?.(frame, sentAt);
+        };
+    }
+    const watcherViews = new Map();
+    function allowed(watcher, owner, line) {
+        return canWatch ? canWatch(watcher, owner, line) : true;
+    }
+    function filteredLine(watcher, owner, name, source, cache) {
+        const [emit, filtered] = (0, replay_listen_1.replayListen)({
+            history: lines[name] == 'video' ? videoHistory : audioHistory,
+            current: function currentIfAllowed() {
+                return allowed(watcher, owner, name) ? source.keyframe()?.event : undefined;
+            },
+            ...(lines[name] == 'video' ? {
+                frame: function lastAllowedFrame(tail) {
+                    return tail.length ? [tail[tail.length - 1]] : [];
+                },
+            } : {}),
+        });
+        const offSource = source.on(function forwardAllowed(frame, sentAt) {
+            if (allowed(watcher, owner, name))
+                emit(frame, sentAt);
+        });
+        const closeFiltered = filtered.close;
+        filtered.close = function closePolicyLine() {
+            offSource();
+            closeFiltered();
+        };
+        cache.filtered.add(filtered);
+        return filtered;
+    }
+    function ownerViewFor(watcher, owner, cache) {
+        let view = cache.owners.get(owner);
+        if (view)
+            return view;
+        const entry = accounts.get(owner);
+        if (!entry)
+            return undefined;
+        const policyLines = {};
+        for (const name of Object.keys(lines))
+            policyLines[name] = filteredLine(watcher, owner, name, entry.view[name], cache);
+        view = (0, rpc_dynamic_1.noStrict)(new Proxy(policyLines, {
+            has(t, k) { return typeof k == 'string' && k in t && allowed(watcher, owner, k); },
+            get(t, k) {
+                if (typeof k != 'string')
+                    return t[k];
+                return k in t && allowed(watcher, owner, k) ? t[k] : undefined;
+            },
+        }));
+        cache.owners.set(owner, view);
+        return view;
+    }
+    function watchOf(watcher) {
+        let cached = watcherViews.get(watcher);
+        if (cached)
+            return cached.root;
+        const owners = new Map();
+        const filtered = new Set();
+        function visible(owner) {
+            return accounts.has(owner) && Object.keys(lines).some(name => allowed(watcher, owner, name));
+        }
+        const root = (0, rpc_dynamic_1.noStrict)(new Proxy({}, {
+            has(_t, k) { return typeof k == 'string' && visible(k); },
+            get(_t, k) {
+                if (typeof k != 'string')
+                    return undefined;
+                return visible(k) ? ownerViewFor(watcher, k, cached) : undefined;
+            },
+        }));
+        cached = { root, owners, filtered };
+        watcherViews.set(watcher, cached);
+        return root;
+    }
+    function dropLines(entry) {
+        for (const name of Object.keys(entry.view))
+            entry.view[name].close();
+    }
+    function closeWatcherCache(cache) {
+        for (const line of cache.filtered)
+            line.close();
+        cache.filtered.clear();
+        cache.owners.clear();
+    }
+    function dropAccount(account) {
+        const entry = accounts.get(account);
+        const ownCache = watcherViews.get(account);
+        if (ownCache)
+            closeWatcherCache(ownCache);
+        watcherViews.delete(account);
+        for (const cache of watcherViews.values()) {
+            const ownerView = cache.owners.get(account);
+            if (ownerView)
+                for (const line of Object.values(ownerView)) {
+                    line.close();
+                    cache.filtered.delete(line);
+                }
+            cache.owners.delete(account);
+        }
+        if (!entry)
+            return;
+        accounts.delete(account);
+        delete watch[account];
+        dropLines(entry);
+    }
+    return {
+        publishOf,
+        watch,
+        watchOf,
+        lines: (account) => linesOf(account).view,
+        accounts: () => Array.from(accounts.keys()),
+        dropAccount,
+        close() {
+            for (const cache of watcherViews.values())
+                closeWatcherCache(cache);
+            for (const entry of accounts.values())
+                dropLines(entry);
+            accounts.clear();
+            watcherViews.clear();
+        },
+    };
+}