@adeeliore/p2p-lan-signaling 0.1.0

package/API_REFERENCE.md

@@ -0,0 +1,158 @@
+# API Reference
+
+## Install
+
+```bash
+npm install @adeeliore/p2p-lan-signaling
+```
+
+## 1. Check Native Availability
+
+```ts
+import { isLanSignalingHostAvailable } from '@adeeliore/p2p-lan-signaling';
+
+if (!isLanSignalingHostAvailable()) {
+  throw new Error('Native LAN signaling host is not available');
+}
+```
+
+## 2. Start A Host
+
+```ts
+import { startLanSignalingHost } from '@adeeliore/p2p-lan-signaling';
+
+const host = await startLanSignalingHost({
+  port: 8080,
+  roomId: 'ROOM-1234',
+  displayName: 'Workshop board',
+  roomSecret: 'shared-secret',
+});
+```
+
+### `startLanSignalingHost(options)`
+
+Starts a native LAN/offline signaling host.
+
+Options:
+
+- `port?`
+- `roomId?`
+- `displayName?`
+- `roomSecret?`
+
+Returns host status:
+
+```ts
+{
+  running: boolean;
+  hostAddress: string | null;
+  port: number | null;
+  url: string | null;
+  roomId?: string | null;
+  serviceName?: string | null;
+  serviceType?: string | null;
+}
+```
+
+## 3. Stop Or Inspect The Host
+
+```ts
+import {
+  getLanSignalingHostStatus,
+  stopLanSignalingHost,
+} from '@adeeliore/p2p-lan-signaling';
+
+const status = await getLanSignalingHostStatus();
+await stopLanSignalingHost();
+```
+
+Methods:
+
+- `getLanSignalingHostStatus()`
+- `stopLanSignalingHost()`
+- `isLanSignalingHostAvailable()`
+
+## 4. Discover Rooms
+
+```ts
+import { discoverLanSignalingRooms } from '@adeeliore/p2p-lan-signaling';
+
+const rooms = await discoverLanSignalingRooms(2500);
+```
+
+### `discoverLanSignalingRooms(timeoutMs?)`
+
+Scans for rooms advertised through `_drawin._tcp`.
+
+Return shape:
+
+```ts
+Array<{
+  serviceName: string;
+  serviceType: string;
+  hostAddress: string;
+  port: number;
+  url: string;
+  roomId?: string | null;
+  displayName?: string | null;
+}>
+```
+
+## 5. Create A Signaling Provider
+
+```ts
+import { createLanSignalingProvider } from '@adeeliore/p2p-lan-signaling';
+
+const provider = createLanSignalingProvider('ws://192.168.0.15:8080');
+```
+
+### `createLanSignalingProvider(signalBaseUrl)`
+
+Creates a signaling-provider object compatible with `@adeeliore/p2p-core`.
+
+Typical integration:
+
+```ts
+import { createP2PSession } from '@adeeliore/p2p-core';
+import {
+  createLanSignalingProvider,
+  discoverLanSignalingRooms,
+} from '@adeeliore/p2p-lan-signaling';
+
+const rooms = await discoverLanSignalingRooms();
+const selectedRoom = rooms[0];
+
+const session = createP2PSession({
+  sessionId: selectedRoom.roomId ?? 'ROOM-1234',
+  accessToken: 'shared-secret',
+  signalingProvider: createLanSignalingProvider(selectedRoom.url),
+});
+```
+
+## 6. Expo Plugin Entry Points
+
+Use one of these plugin references:
+
+- `@adeeliore/p2p-lan-signaling/app.plugin`
+- `@adeeliore/p2p-lan-signaling/plugin/withP2PLanSignaling`
+
+Example:
+
+```json
+{
+  "expo": {
+    "plugins": [
+      "@adeeliore/p2p-lan-signaling/app.plugin"
+    ]
+  }
+}
+```
+
+## Constants
+
+- `LAN_SIGNALING_DEFAULT_PORT`
+- `LAN_SIGNALING_DISCOVERY_TIMEOUT_MS`
+- `LAN_SIGNALING_SERVICE_TYPE`
+
+Primary naming uses `Lan*`.
+`Offline*` exports are compatibility aliases.

package/CHANGELOG.md

@@ -0,0 +1,9 @@
+# Changelog
+
+## 0.1.0
+
+- initial public package layout;
+- JS API for starting/stopping native LAN signaling hosts;
+- LAN room discovery over `_drawin._tcp`;
+- `SignalingProvider` bridge for `@adeeliore/p2p-core`;
+- Expo config plugin with Android and iOS native templates.

package/LICENSE

@@ -0,0 +1,12 @@
+Copyright (C) 2026
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,118 @@
+# `@adeeliore/p2p-lan-signaling`
+
+LAN and offline signaling adapter for React Native apps.
+
+This package adds two things on top of a P2P app architecture:
+
+- native LAN signaling host on Android and iOS;
+- room discovery over `_drawin._tcp`;
+- a signaling-provider adapter compatible with `@adeeliore/p2p-core`;
+- an Expo config plugin that restores native code after `expo prebuild`.
+
+Primary public naming uses the `Lan*` prefix.
+`Offline*` exports remain available as compatibility aliases for existing app code.
+
+## Installation
+
+```bash
+npm install @adeeliore/p2p-lan-signaling
+```
+
+If the app also uses the P2P runtime:
+
+```bash
+npm install @adeeliore/p2p-core
+```
+
+## Typical Flow
+
+### Host device
+
+```ts
+import { startLanSignalingHost } from '@adeeliore/p2p-lan-signaling';
+
+const host = await startLanSignalingHost({
+  port: 8080,
+  roomId: 'ROOM-ABCD1234',
+  displayName: 'Workshop board',
+  roomSecret: 'shared-secret',
+});
+```
+
+### Participant device
+
+```ts
+import { discoverLanSignalingRooms } from '@adeeliore/p2p-lan-signaling';
+
+const rooms = await discoverLanSignalingRooms();
+const selectedRoom = rooms[0];
+```
+
+### Connect the P2P runtime
+
+```ts
+import { createP2PSession } from '@adeeliore/p2p-core';
+import {
+  createLanSignalingProvider,
+  startLanSignalingHost,
+} from '@adeeliore/p2p-lan-signaling';
+
+const host = await startLanSignalingHost({
+  roomId: 'ROOM-ABCD1234',
+  displayName: 'Workshop board',
+  roomSecret: 'shared-secret',
+});
+
+const session = createP2PSession({
+  sessionId: 'ROOM-ABCD1234',
+  clientId: 'teacher',
+  accessToken: 'shared-secret',
+  signalingProvider: createLanSignalingProvider(host.url!),
+});
+
+session.connect();
+```
+
+## Expo Plugin
+
+Add the package plugin to app config:
+
+```json
+{
+  "expo": {
+    "plugins": [
+      "@adeeliore/p2p-lan-signaling/app.plugin"
+    ]
+  }
+}
+```
+
+Then rebuild the native app:
+
+```bash
+npx expo prebuild -p android
+npx expo prebuild -p ios
+```
+
+## Security Defaults
+
+- room discovery advertises room metadata, not the room secret;
+- protected rooms use `accessToken` or `roomSecret`;
+- native hosts validate room id, client id, participant count and frame size.
+
+## Error Model
+
+Provider and native-boundary failures use stable error codes.
+
+Examples:
+
+- `ERR_UNSUPPORTED_PLATFORM`
+- `ERR_NATIVE_MODULE_MISSING`
+- `ERR_SIGNALING_NOT_CONNECTED`
+- `ERR_INVALID_SIGNAL_MESSAGE`
+- `ERR_SIGNALING_SOCKET_ERROR`
+
+## Documentation
+
+- usage-oriented API reference: [API_REFERENCE.md](/Users/whoami/diplom-p2p/DrawingApp/packages/p2p-lan-signaling/API_REFERENCE.md)
+- changelog: [CHANGELOG.md](/Users/whoami/diplom-p2p/DrawingApp/packages/p2p-lan-signaling/CHANGELOG.md)

package/app.plugin.js

@@ -0,0 +1 @@
+module.exports = require('./plugin/withP2PLanSignaling');

package/dist/constants.d.ts

@@ -0,0 +1,17 @@
+export declare const OFFLINE_SIGNALING_NATIVE_MODULE_NAME = "OfflineSignalingHost";
+export declare const LAN_SIGNALING_DEFAULT_PORT = 8080;
+export declare const LAN_SIGNALING_DISCOVERY_TIMEOUT_MS = 2500;
+export declare const LAN_SIGNALING_SERVICE_TYPE = "_drawin._tcp";
+export declare const LAN_SIGNALING_MESSAGE_TYPE: {
+    readonly WELCOME: "welcome";
+    readonly PEER_JOINED: "peer-joined";
+    readonly PEER_LEFT: "peer-left";
+    readonly PONG: "pong";
+    readonly OFFER: "offer";
+    readonly ANSWER: "answer";
+    readonly ICE: "ice";
+    readonly ERROR: "error";
+};
+export declare const UNSUPPORTED_PLATFORM_ERROR = "LAN signaling host is supported only on Android and iOS";
+export declare const MISSING_NATIVE_MODULE_ERROR = "LAN signaling native module is not available. Rebuild the Android/iOS dev app with expo run:android or expo run:ios; Expo Go cannot load this module.";
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,oCAAoC,yBAAyB,CAAC;AAC3E,eAAO,MAAM,0BAA0B,OAAO,CAAC;AAC/C,eAAO,MAAM,kCAAkC,OAAO,CAAC;AACvD,eAAO,MAAM,0BAA0B,iBAAiB,CAAC;AAEzD,eAAO,MAAM,0BAA0B;;;;;;;;;CAS7B,CAAC;AAEX,eAAO,MAAM,0BAA0B,4DACsB,CAAC;AAE9D,eAAO,MAAM,2BAA2B,0JACmH,CAAC"}

package/dist/constants.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MISSING_NATIVE_MODULE_ERROR = exports.UNSUPPORTED_PLATFORM_ERROR = exports.LAN_SIGNALING_MESSAGE_TYPE = exports.LAN_SIGNALING_SERVICE_TYPE = exports.LAN_SIGNALING_DISCOVERY_TIMEOUT_MS = exports.LAN_SIGNALING_DEFAULT_PORT = exports.OFFLINE_SIGNALING_NATIVE_MODULE_NAME = void 0;
+exports.OFFLINE_SIGNALING_NATIVE_MODULE_NAME = 'OfflineSignalingHost';
+exports.LAN_SIGNALING_DEFAULT_PORT = 8080;
+exports.LAN_SIGNALING_DISCOVERY_TIMEOUT_MS = 2500;
+exports.LAN_SIGNALING_SERVICE_TYPE = '_drawin._tcp';
+exports.LAN_SIGNALING_MESSAGE_TYPE = {
+    WELCOME: 'welcome',
+    PEER_JOINED: 'peer-joined',
+    PEER_LEFT: 'peer-left',
+    PONG: 'pong',
+    OFFER: 'offer',
+    ANSWER: 'answer',
+    ICE: 'ice',
+    ERROR: 'error',
+};
+exports.UNSUPPORTED_PLATFORM_ERROR = 'LAN signaling host is supported only on Android and iOS';
+exports.MISSING_NATIVE_MODULE_ERROR = 'LAN signaling native module is not available. Rebuild the Android/iOS dev app with expo run:android or expo run:ios; Expo Go cannot load this module.';

package/dist/discovery.d.ts

@@ -0,0 +1,3 @@
+import { LanDiscoveredRoom } from './types';
+export declare function discoverLanSignalingRooms(timeoutMs?: number): Promise<LanDiscoveredRoom[]>;
+//# sourceMappingURL=discovery.d.ts.map

package/dist/discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../src/discovery.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAE5C,wBAAsB,yBAAyB,CAC3C,SAAS,SAAqC,GAC/C,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAG9B"}

package/dist/discovery.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverLanSignalingRooms = discoverLanSignalingRooms;
+const constants_1 = require("./constants");
+const nativeModule_1 = require("./nativeModule");
+const roomUtils_1 = require("./roomUtils");
+async function discoverLanSignalingRooms(timeoutMs = constants_1.LAN_SIGNALING_DISCOVERY_TIMEOUT_MS) {
+    const rooms = await (0, nativeModule_1.getNativeModule)().discoverHosts(timeoutMs);
+    return (0, roomUtils_1.dedupeRooms)(rooms);
+}

package/dist/errors.d.ts

@@ -0,0 +1,16 @@
+export declare const LAN_SIGNALING_ERROR_CODE: {
+    readonly UNSUPPORTED_PLATFORM: "ERR_UNSUPPORTED_PLATFORM";
+    readonly NATIVE_MODULE_MISSING: "ERR_NATIVE_MODULE_MISSING";
+    readonly SIGNALING_NOT_CONNECTED: "ERR_SIGNALING_NOT_CONNECTED";
+    readonly INVALID_SIGNAL_MESSAGE: "ERR_INVALID_SIGNAL_MESSAGE";
+    readonly SIGNALING_SOCKET_ERROR: "ERR_SIGNALING_SOCKET_ERROR";
+};
+export type LanSignalingErrorCode = typeof LAN_SIGNALING_ERROR_CODE[keyof typeof LAN_SIGNALING_ERROR_CODE];
+export interface LanSignalingErrorPayload {
+    code: LanSignalingErrorCode;
+    message: string;
+}
+export declare function createLanSignalingError(code: LanSignalingErrorCode, message: string): Error & {
+    code: LanSignalingErrorCode;
+};
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,wBAAwB;;;;;;CAM3B,CAAC;AAEX,MAAM,MAAM,qBAAqB,GAC7B,OAAO,wBAAwB,CAAC,MAAM,OAAO,wBAAwB,CAAC,CAAC;AAE3E,MAAM,WAAW,wBAAwB;IACrC,IAAI,EAAE,qBAAqB,CAAC;IAC5B,OAAO,EAAE,MAAM,CAAC;CACnB;AAED,wBAAgB,uBAAuB,CACnC,IAAI,EAAE,qBAAqB,EAC3B,OAAO,EAAE,MAAM,GAChB,KAAK,GAAG;IAAE,IAAI,EAAE,qBAAqB,CAAA;CAAE,CAIzC"}

package/dist/errors.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LAN_SIGNALING_ERROR_CODE = void 0;
+exports.createLanSignalingError = createLanSignalingError;
+exports.LAN_SIGNALING_ERROR_CODE = {
+    UNSUPPORTED_PLATFORM: 'ERR_UNSUPPORTED_PLATFORM',
+    NATIVE_MODULE_MISSING: 'ERR_NATIVE_MODULE_MISSING',
+    SIGNALING_NOT_CONNECTED: 'ERR_SIGNALING_NOT_CONNECTED',
+    INVALID_SIGNAL_MESSAGE: 'ERR_INVALID_SIGNAL_MESSAGE',
+    SIGNALING_SOCKET_ERROR: 'ERR_SIGNALING_SOCKET_ERROR',
+};
+function createLanSignalingError(code, message) {
+    const error = new Error(message);
+    error.code = code;
+    return error;
+}

package/dist/host.d.ts

@@ -0,0 +1,5 @@
+import { LanSignalingHostOptions, LanSignalingHostStatus } from './types';
+export declare function startLanSignalingHost(options?: LanSignalingHostOptions): Promise<LanSignalingHostStatus>;
+export declare function stopLanSignalingHost(): Promise<void>;
+export declare function getLanSignalingHostStatus(): Promise<LanSignalingHostStatus>;
+//# sourceMappingURL=host.d.ts.map

package/dist/host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"host.d.ts","sourceRoot":"","sources":["../src/host.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,uBAAuB,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAE1E,wBAAsB,qBAAqB,CACvC,OAAO,GAAE,uBAA4B,GACtC,OAAO,CAAC,sBAAsB,CAAC,CASjC;AAED,wBAAsB,oBAAoB,IAAI,OAAO,CAAC,IAAI,CAAC,CAG1D;AAED,wBAAsB,yBAAyB,IAAI,OAAO,CAAC,sBAAsB,CAAC,CAMjF"}

package/dist/host.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startLanSignalingHost = startLanSignalingHost;
+exports.stopLanSignalingHost = stopLanSignalingHost;
+exports.getLanSignalingHostStatus = getLanSignalingHostStatus;
+const react_native_1 = require("react-native");
+const constants_1 = require("./constants");
+const nativeModule_1 = require("./nativeModule");
+async function startLanSignalingHost(options = {}) {
+    var _a, _b, _c, _d;
+    (0, nativeModule_1.assertSupportedPlatform)();
+    return (0, nativeModule_1.getNativeModule)().startHost((_a = options.port) !== null && _a !== void 0 ? _a : constants_1.LAN_SIGNALING_DEFAULT_PORT, (_b = options.roomId) !== null && _b !== void 0 ? _b : null, (_c = options.displayName) !== null && _c !== void 0 ? _c : null, (_d = options.roomSecret) !== null && _d !== void 0 ? _d : null);
+}
+async function stopLanSignalingHost() {
+    (0, nativeModule_1.assertSupportedPlatform)();
+    return (0, nativeModule_1.getNativeModule)().stopHost();
+}
+async function getLanSignalingHostStatus() {
+    if (react_native_1.Platform.OS !== 'android' && react_native_1.Platform.OS !== 'ios') {
+        return (0, nativeModule_1.createEmptyHostStatus)();
+    }
+    return (0, nativeModule_1.getNativeModule)().getStatus();
+}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export * from './constants';
+export * from './discovery';
+export * from './errors';
+export * from './host';
+export * from './provider';
+export * from './types';
+export { discoverLanSignalingRooms as discoverOfflineSignalingHosts, } from './discovery';
+export { getLanSignalingHostStatus as getOfflineSignalingHostStatus, startLanSignalingHost as startOfflineSignalingHost, stopLanSignalingHost as stopOfflineSignalingHost, } from './host';
+export { isLanSignalingHostAvailable as isOfflineSignalingHostAvailable } from './nativeModule';
+export { isLanSignalingHostAvailable } from './nativeModule';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC;AACvB,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC;AAIxB,OAAO,EACH,yBAAyB,IAAI,6BAA6B,GAC7D,MAAM,aAAa,CAAC;AACrB,OAAO,EACH,yBAAyB,IAAI,6BAA6B,EAC1D,qBAAqB,IAAI,yBAAyB,EAClD,oBAAoB,IAAI,wBAAwB,GACnD,MAAM,QAAQ,CAAC;AAChB,OAAO,EAAE,2BAA2B,IAAI,+BAA+B,EAAE,MAAM,gBAAgB,CAAC;AAChG,OAAO,EAAE,2BAA2B,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/index.js

@@ -0,0 +1,35 @@
+"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 });
+exports.isLanSignalingHostAvailable = exports.isOfflineSignalingHostAvailable = exports.stopOfflineSignalingHost = exports.startOfflineSignalingHost = exports.getOfflineSignalingHostStatus = exports.discoverOfflineSignalingHosts = void 0;
+__exportStar(require("./constants"), exports);
+__exportStar(require("./discovery"), exports);
+__exportStar(require("./errors"), exports);
+__exportStar(require("./host"), exports);
+__exportStar(require("./provider"), exports);
+__exportStar(require("./types"), exports);
+// Primary public API uses the `Lan*` naming.
+// `Offline*` exports remain as compatibility aliases for existing app code.
+var discovery_1 = require("./discovery");
+Object.defineProperty(exports, "discoverOfflineSignalingHosts", { enumerable: true, get: function () { return discovery_1.discoverLanSignalingRooms; } });
+var host_1 = require("./host");
+Object.defineProperty(exports, "getOfflineSignalingHostStatus", { enumerable: true, get: function () { return host_1.getLanSignalingHostStatus; } });
+Object.defineProperty(exports, "startOfflineSignalingHost", { enumerable: true, get: function () { return host_1.startLanSignalingHost; } });
+Object.defineProperty(exports, "stopOfflineSignalingHost", { enumerable: true, get: function () { return host_1.stopLanSignalingHost; } });
+var nativeModule_1 = require("./nativeModule");
+Object.defineProperty(exports, "isOfflineSignalingHostAvailable", { enumerable: true, get: function () { return nativeModule_1.isLanSignalingHostAvailable; } });
+var nativeModule_2 = require("./nativeModule");
+Object.defineProperty(exports, "isLanSignalingHostAvailable", { enumerable: true, get: function () { return nativeModule_2.isLanSignalingHostAvailable; } });

package/dist/messageValidation.d.ts

@@ -0,0 +1,3 @@
+import { CompatibleIncomingServerMessage } from './types';
+export declare function parseIncomingServerMessage(rawMessage: string): CompatibleIncomingServerMessage | null;
+//# sourceMappingURL=messageValidation.d.ts.map

package/dist/messageValidation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messageValidation.d.ts","sourceRoot":"","sources":["../src/messageValidation.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,+BAA+B,EAKlC,MAAM,SAAS,CAAC;AAGjB,wBAAgB,0BAA0B,CACtC,UAAU,EAAE,MAAM,GACnB,+BAA+B,GAAG,IAAI,CAmCxC"}

package/dist/messageValidation.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIncomingServerMessage = parseIncomingServerMessage;
+const constants_1 = require("./constants");
+function parseIncomingServerMessage(rawMessage) {
+    let parsed;
+    try {
+        parsed = JSON.parse(rawMessage);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== 'object') {
+        return null;
+    }
+    const candidate = parsed;
+    if (typeof candidate.type !== 'string') {
+        return null;
+    }
+    switch (candidate.type) {
+        case constants_1.LAN_SIGNALING_MESSAGE_TYPE.WELCOME:
+            return isValidWelcomeMessage(candidate) ? candidate : null;
+        case constants_1.LAN_SIGNALING_MESSAGE_TYPE.PEER_JOINED:
+            return isValidPeerJoinedMessage(candidate) ? candidate : null;
+        case constants_1.LAN_SIGNALING_MESSAGE_TYPE.PEER_LEFT:
+            return isValidPeerLeftMessage(candidate) ? candidate : null;
+        case constants_1.LAN_SIGNALING_MESSAGE_TYPE.OFFER:
+        case constants_1.LAN_SIGNALING_MESSAGE_TYPE.ANSWER:
+        case constants_1.LAN_SIGNALING_MESSAGE_TYPE.ICE:
+            return isValidRelayMessage(candidate) ? candidate : null;
+        case constants_1.LAN_SIGNALING_MESSAGE_TYPE.PONG:
+            return { type: constants_1.LAN_SIGNALING_MESSAGE_TYPE.PONG };
+        case constants_1.LAN_SIGNALING_MESSAGE_TYPE.ERROR:
+            return isValidErrorMessage(candidate) ? candidate : null;
+        default:
+            return null;
+    }
+}
+function isValidWelcomeMessage(candidate) {
+    if (!candidate || typeof candidate !== 'object') {
+        return false;
+    }
+    const value = candidate;
+    return (value.type === constants_1.LAN_SIGNALING_MESSAGE_TYPE.WELCOME &&
+        typeof value.sessionId === 'string' &&
+        typeof value.clientId === 'string' &&
+        Array.isArray(value.peers) &&
+        value.peers.every((peer) => Boolean(peer) &&
+            typeof peer === 'object' &&
+            typeof peer.clientId === 'string'));
+}
+function isValidPeerJoinedMessage(candidate) {
+    if (!candidate || typeof candidate !== 'object') {
+        return false;
+    }
+    const value = candidate;
+    return (value.type === constants_1.LAN_SIGNALING_MESSAGE_TYPE.PEER_JOINED &&
+        typeof value.sessionId === 'string' &&
+        typeof value.clientId === 'string');
+}
+function isValidPeerLeftMessage(candidate) {
+    if (!candidate || typeof candidate !== 'object') {
+        return false;
+    }
+    const value = candidate;
+    return (value.type === constants_1.LAN_SIGNALING_MESSAGE_TYPE.PEER_LEFT &&
+        typeof value.sessionId === 'string' &&
+        typeof value.clientId === 'string');
+}
+function isValidRelayMessage(candidate) {
+    if (!candidate || typeof candidate !== 'object') {
+        return false;
+    }
+    const value = candidate;
+    return ((value.type === constants_1.LAN_SIGNALING_MESSAGE_TYPE.OFFER ||
+        value.type === constants_1.LAN_SIGNALING_MESSAGE_TYPE.ANSWER ||
+        value.type === constants_1.LAN_SIGNALING_MESSAGE_TYPE.ICE) &&
+        typeof value.sessionId === 'string' &&
+        typeof value.from === 'string' &&
+        typeof value.to === 'string');
+}
+function isValidErrorMessage(candidate) {
+    if (!candidate || typeof candidate !== 'object') {
+        return false;
+    }
+    const value = candidate;
+    return (value.type === constants_1.LAN_SIGNALING_MESSAGE_TYPE.ERROR &&
+        typeof value.code === 'string' &&
+        typeof value.message === 'string');
+}

package/dist/nativeModule.d.ts

@@ -0,0 +1,7 @@
+import { LanSignalingHostStatus, OfflineSignalingNativeModule } from './types';
+export declare function isLanSignalingPlatform(): boolean;
+export declare function isLanSignalingHostAvailable(): boolean;
+export declare function assertSupportedPlatform(): void;
+export declare function getNativeModule(): OfflineSignalingNativeModule;
+export declare function createEmptyHostStatus(): LanSignalingHostStatus;
+//# sourceMappingURL=nativeModule.d.ts.map

package/dist/nativeModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nativeModule.d.ts","sourceRoot":"","sources":["../src/nativeModule.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,sBAAsB,EAAE,4BAA4B,EAAE,MAAM,SAAS,CAAC;AAE/E,wBAAgB,sBAAsB,IAAI,OAAO,CAEhD;AAED,wBAAgB,2BAA2B,IAAI,OAAO,CAErD;AAED,wBAAgB,uBAAuB,IAAI,IAAI,CAO9C;AAED,wBAAgB,eAAe,IAAI,4BAA4B,CAa9D;AAED,wBAAgB,qBAAqB,IAAI,sBAAsB,CAU9D"}

package/dist/nativeModule.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLanSignalingPlatform = isLanSignalingPlatform;
+exports.isLanSignalingHostAvailable = isLanSignalingHostAvailable;
+exports.assertSupportedPlatform = assertSupportedPlatform;
+exports.getNativeModule = getNativeModule;
+exports.createEmptyHostStatus = createEmptyHostStatus;
+const react_native_1 = require("react-native");
+const constants_1 = require("./constants");
+const errors_1 = require("./errors");
+function isLanSignalingPlatform() {
+    return react_native_1.Platform.OS === 'android' || react_native_1.Platform.OS === 'ios';
+}
+function isLanSignalingHostAvailable() {
+    return isLanSignalingPlatform() && Boolean(react_native_1.NativeModules[constants_1.OFFLINE_SIGNALING_NATIVE_MODULE_NAME]);
+}
+function assertSupportedPlatform() {
+    if (!isLanSignalingPlatform()) {
+        throw (0, errors_1.createLanSignalingError)(errors_1.LAN_SIGNALING_ERROR_CODE.UNSUPPORTED_PLATFORM, constants_1.UNSUPPORTED_PLATFORM_ERROR);
+    }
+}
+function getNativeModule() {
+    const nativeModule = react_native_1.NativeModules[constants_1.OFFLINE_SIGNALING_NATIVE_MODULE_NAME];
+    if (!nativeModule) {
+        throw (0, errors_1.createLanSignalingError)(errors_1.LAN_SIGNALING_ERROR_CODE.NATIVE_MODULE_MISSING, constants_1.MISSING_NATIVE_MODULE_ERROR);
+    }
+    return nativeModule;
+}
+function createEmptyHostStatus() {
+    return {
+        running: false,
+        hostAddress: null,
+        port: null,
+        url: null,
+        roomId: null,
+        serviceName: null,
+        serviceType: null,
+    };
+}

package/dist/provider.d.ts

@@ -0,0 +1,20 @@
+import { CompatibleSignalingProvider, CompatibleSignalingProviderConnectOptions, CompatibleSignalingProviderHandlers } from './types';
+interface LanWebSocketSignalingProviderOptions {
+    signalBaseUrl: string;
+    createWebSocket?: (url: string) => WebSocket;
+}
+export declare class LanWebSocketSignalingProvider implements CompatibleSignalingProvider {
+    private readonly signalBaseUrl;
+    private readonly createWebSocketInstance;
+    private socket;
+    constructor(options: LanWebSocketSignalingProviderOptions);
+    connect(options: CompatibleSignalingProviderConnectOptions, handlers: CompatibleSignalingProviderHandlers): void;
+    disconnect(code?: number, reason?: string): void;
+    sendPing(): void;
+    sendRelay(type: 'offer' | 'answer' | 'ice', to: string, payload: unknown): void;
+    isConnected(): boolean;
+    private send;
+}
+export declare function createLanSignalingProvider(signalBaseUrl: string): CompatibleSignalingProvider;
+export {};
+//# sourceMappingURL=provider.d.ts.map