@adeeliore/p2p-core 0.1.0

package/dist/sync/constants.d.ts

@@ -0,0 +1,10 @@
+export declare const SYNC_NAMESPACE = "__p2p_core_sync__";
+export declare const SYNC_VERSION = 1;
+export declare const SYNC_STRATEGY: {
+    readonly EVENTS: "events";
+    readonly PULL_ON_CONNECT: "pull-on-connect";
+    readonly PUSH_TO_NEW_PEER: "push-to-new-peer";
+    readonly SNAPSHOT_AND_LIVE: "snapshot-and-live";
+};
+export declare const DEFAULT_SYNC_STRATEGY: "events";
+//# sourceMappingURL=constants.d.ts.map

package/dist/sync/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/sync/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,sBAAsB,CAAC;AAClD,eAAO,MAAM,YAAY,IAAI,CAAC;AAE9B,eAAO,MAAM,aAAa;;;;;CAKhB,CAAC;AAEX,eAAO,MAAM,qBAAqB,UAAuB,CAAC"}

package/dist/sync/constants.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SYNC_STRATEGY = exports.SYNC_STRATEGY = exports.SYNC_VERSION = exports.SYNC_NAMESPACE = void 0;
+exports.SYNC_NAMESPACE = '__p2p_core_sync__';
+exports.SYNC_VERSION = 1;
+exports.SYNC_STRATEGY = {
+    EVENTS: 'events',
+    PULL_ON_CONNECT: 'pull-on-connect',
+    PUSH_TO_NEW_PEER: 'push-to-new-peer',
+    SNAPSHOT_AND_LIVE: 'snapshot-and-live',
+};
+exports.DEFAULT_SYNC_STRATEGY = exports.SYNC_STRATEGY.EVENTS;

package/dist/sync/engine.d.ts

@@ -0,0 +1,13 @@
+import { P2PSession } from '../session';
+import { P2PSyncEngine } from './types';
+/**
+ * Creates a pluggable state synchronization engine on top of an existing
+ * `P2PSession`.
+ *
+ * The sync engine adds:
+ * - domain-level event sync
+ * - snapshot request/response flow
+ * - built-in sync strategies
+ */
+export declare function createP2PSyncEngine(session: P2PSession): P2PSyncEngine;
+//# sourceMappingURL=engine.d.ts.map

package/dist/sync/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../src/sync/engine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,EAA8D,aAAa,EAAgB,MAAM,SAAS,CAAC;AAgIlH;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,UAAU,GAAG,aAAa,CAEtE"}

package/dist/sync/engine.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createP2PSyncEngine = createP2PSyncEngine;
+const constants_1 = require("./constants");
+class SessionSyncEngine {
+    constructor(session) {
+        this.domains = new Map();
+        this.unsubscribers = [];
+        this.session = session;
+        this.unsubscribers.push(session.on('peerMessage', ({ peerId, message }) => {
+            this.handlePeerMessage(peerId, message);
+        }), session.on('peerDataOpen', ({ peerId, joinKind }) => {
+            this.handlePeerDataOpen(peerId, joinKind);
+        }));
+    }
+    registerDomain(registration) {
+        var _a;
+        this.domains.set(registration.domain, {
+            strategy: (_a = registration.strategy) !== null && _a !== void 0 ? _a : constants_1.DEFAULT_SYNC_STRATEGY,
+            registration: registration,
+        });
+        return () => {
+            this.domains.delete(registration.domain);
+        };
+    }
+    sendEvent(domain, payload, options) {
+        var _a, _b;
+        const envelope = this.createEnvelope(domain, 'event', payload);
+        const encoded = JSON.stringify(envelope);
+        const targetPeerId = (_a = options === null || options === void 0 ? void 0 : options.targetPeerId) === null || _a === void 0 ? void 0 : _a.trim();
+        const peerIds = targetPeerId ? [targetPeerId] : (_b = options === null || options === void 0 ? void 0 : options.peerIds) !== null && _b !== void 0 ? _b : undefined;
+        return this.session.broadcast(encoded, peerIds);
+    }
+    requestSnapshot(domain, targetPeerId) {
+        const envelope = this.createEnvelope(domain, 'snapshotRequest', { scope: 'full' });
+        return this.session.sendTo(targetPeerId, JSON.stringify(envelope));
+    }
+    destroy() {
+        this.unsubscribers.splice(0).forEach((unsubscribe) => unsubscribe());
+        this.domains.clear();
+    }
+    handlePeerMessage(peerId, message) {
+        var _a, _b, _c, _d;
+        const decoded = decodeSyncEnvelope(message);
+        if (!decoded) {
+            return;
+        }
+        const registered = this.domains.get(decoded.domain);
+        if (!registered) {
+            return;
+        }
+        const context = {
+            peerId,
+            senderId: decoded.senderId,
+            session: this.session,
+        };
+        if (decoded.kind === 'event') {
+            (_b = (_a = registered.registration).applyEvent) === null || _b === void 0 ? void 0 : _b.call(_a, decoded.payload, context);
+            return;
+        }
+        if (decoded.kind === 'snapshotRequest') {
+            if (!registered.registration.getSnapshot) {
+                return;
+            }
+            const snapshot = registered.registration.getSnapshot({ session: this.session });
+            const snapshotEnvelope = this.createEnvelope(decoded.domain, 'snapshotState', snapshot);
+            this.session.sendTo(peerId, JSON.stringify(snapshotEnvelope));
+            return;
+        }
+        if (decoded.kind === 'snapshotState') {
+            (_d = (_c = registered.registration).applySnapshot) === null || _d === void 0 ? void 0 : _d.call(_c, decoded.payload, context);
+        }
+    }
+    handlePeerDataOpen(peerId, joinKind) {
+        this.domains.forEach(({ registration, strategy }, domain) => {
+            if (joinKind === 'existing' && shouldPullSnapshot(strategy)) {
+                this.requestSnapshot(domain, peerId);
+                return;
+            }
+            if (joinKind === 'new' && shouldPushSnapshot(strategy) && registration.getSnapshot) {
+                const snapshot = registration.getSnapshot({ session: this.session });
+                const snapshotEnvelope = this.createEnvelope(domain, 'snapshotState', snapshot);
+                this.session.sendTo(peerId, JSON.stringify(snapshotEnvelope));
+            }
+        });
+    }
+    createEnvelope(domain, kind, payload) {
+        return {
+            namespace: constants_1.SYNC_NAMESPACE,
+            version: constants_1.SYNC_VERSION,
+            domain,
+            kind,
+            id: `${domain}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+            ts: Date.now(),
+            senderId: this.session.getLocalPeerId(),
+            payload,
+        };
+    }
+}
+/**
+ * Creates a pluggable state synchronization engine on top of an existing
+ * `P2PSession`.
+ *
+ * The sync engine adds:
+ * - domain-level event sync
+ * - snapshot request/response flow
+ * - built-in sync strategies
+ */
+function createP2PSyncEngine(session) {
+    return new SessionSyncEngine(session);
+}
+function decodeSyncEnvelope(message) {
+    let parsed;
+    try {
+        parsed = JSON.parse(message);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== 'object') {
+        return null;
+    }
+    const candidate = parsed;
+    if (candidate.namespace !== constants_1.SYNC_NAMESPACE ||
+        candidate.version !== constants_1.SYNC_VERSION ||
+        typeof candidate.domain !== 'string' ||
+        (candidate.kind !== 'event' && candidate.kind !== 'snapshotRequest' && candidate.kind !== 'snapshotState')) {
+        return null;
+    }
+    return candidate;
+}
+function shouldPullSnapshot(strategy) {
+    return strategy === constants_1.SYNC_STRATEGY.PULL_ON_CONNECT || strategy === constants_1.SYNC_STRATEGY.SNAPSHOT_AND_LIVE;
+}
+function shouldPushSnapshot(strategy) {
+    return strategy === constants_1.SYNC_STRATEGY.PUSH_TO_NEW_PEER || strategy === constants_1.SYNC_STRATEGY.SNAPSHOT_AND_LIVE;
+}

package/dist/sync/index.d.ts

@@ -0,0 +1,4 @@
+export * from './constants';
+export * from './engine';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/sync/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/sync/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC"}

package/dist/sync/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./constants"), exports);
+__exportStar(require("./engine"), exports);
+__exportStar(require("./types"), exports);

package/dist/sync/types.d.ts

@@ -0,0 +1,61 @@
+import { P2PSession, PeerJoinKind } from '../session';
+/**
+ * Built-in synchronization strategies for a registered sync domain.
+ */
+export type SyncStrategy = 'events' | 'pull-on-connect' | 'push-to-new-peer' | 'snapshot-and-live';
+/**
+ * Internal sync transport envelope carried over the session DataChannel.
+ */
+export interface SyncEnvelope<TPayload = unknown> {
+    namespace: '__p2p_core_sync__';
+    version: 1;
+    domain: string;
+    kind: 'event' | 'snapshotRequest' | 'snapshotState';
+    id: string;
+    ts: number;
+    senderId: string | null;
+    payload: TPayload;
+}
+/**
+ * Context passed to sync event handlers.
+ */
+export interface SyncEventContext {
+    peerId: string;
+    senderId: string | null;
+    session: P2PSession;
+}
+/**
+ * Context passed to snapshot handlers.
+ */
+export interface SyncSnapshotContext extends SyncEventContext {
+    joinKind?: PeerJoinKind;
+}
+/**
+ * Registration contract for a state synchronization domain.
+ */
+export interface SyncDomainRegistration<TEvent = unknown, TSnapshot = unknown> {
+    domain: string;
+    strategy?: SyncStrategy;
+    getSnapshot?: (context: {
+        session: P2PSession;
+    }) => TSnapshot;
+    applySnapshot?: (snapshot: TSnapshot, context: SyncSnapshotContext) => void;
+    applyEvent?: (event: TEvent, context: SyncEventContext) => void;
+}
+/**
+ * Optional routing options for outbound sync events.
+ */
+export interface SyncEventSendOptions {
+    targetPeerId?: string;
+    peerIds?: string[];
+}
+/**
+ * Pluggable synchronization engine attached to a `P2PSession`.
+ */
+export interface P2PSyncEngine {
+    registerDomain: <TEvent = unknown, TSnapshot = unknown>(registration: SyncDomainRegistration<TEvent, TSnapshot>) => () => void;
+    sendEvent: <TEvent = unknown>(domain: string, payload: TEvent, options?: SyncEventSendOptions) => number;
+    requestSnapshot: (domain: string, targetPeerId: string) => boolean;
+    destroy: () => void;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/sync/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/sync/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAEtD;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,iBAAiB,GAAG,kBAAkB,GAAG,mBAAmB,CAAC;AAEnG;;GAEG;AACH,MAAM,WAAW,YAAY,CAAC,QAAQ,GAAG,OAAO;IAC5C,SAAS,EAAE,mBAAmB,CAAC;IAC/B,OAAO,EAAE,CAAC,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,OAAO,GAAG,iBAAiB,GAAG,eAAe,CAAC;IACpD,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,OAAO,EAAE,QAAQ,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,OAAO,EAAE,UAAU,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,mBAAoB,SAAQ,gBAAgB;IACzD,QAAQ,CAAC,EAAE,YAAY,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB,CAAC,MAAM,GAAG,OAAO,EAAE,SAAS,GAAG,OAAO;IACzE,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB,WAAW,CAAC,EAAE,CAAC,OAAO,EAAE;QAAE,OAAO,EAAE,UAAU,CAAA;KAAE,KAAK,SAAS,CAAC;IAC9D,aAAa,CAAC,EAAE,CAAC,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,mBAAmB,KAAK,IAAI,CAAC;IAC5E,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;CACnE;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACjC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC1B,cAAc,EAAE,CAAC,MAAM,GAAG,OAAO,EAAE,SAAS,GAAG,OAAO,EAClD,YAAY,EAAE,sBAAsB,CAAC,MAAM,EAAE,SAAS,CAAC,KACtD,MAAM,IAAI,CAAC;IAChB,SAAS,EAAE,CAAC,MAAM,GAAG,OAAO,EACxB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,oBAAoB,KAC7B,MAAM,CAAC;IACZ,eAAe,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC;IACnE,OAAO,EAAE,MAAM,IAAI,CAAC;CACvB"}

package/dist/sync/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@adeeliore/p2p-core",
+  "description": "Reusable P2P session runtime for React Native apps built on WebSocket signaling and WebRTC DataChannels.",
+  "version": "0.1.0",
+  "license": "0BSD",
+  "private": false,
+  "main": "./dist/index.js",
+  "react-native": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md",
+    "API_REFERENCE.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "react-native": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "keywords": [
+    "p2p",
+    "webrtc",
+    "react-native",
+    "signaling",
+    "datachannel",
+    "collaboration"
+  ],
+  "scripts": {
+    "build": "node ../../node_modules/typescript/lib/tsc.js -p tsconfig.build.json",
+    "typecheck": "node ../../node_modules/typescript/lib/tsc.js -p tsconfig.json --noEmit",
+    "test": "npm run build && node --test tests/**/*.test.cjs",
+    "prepublishOnly": "npm run build"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "react-native": "*",
+    "react-native-webrtc": "^124.0.7"
+  }
+}