@naviedu/room-platform-react 0.0.65 → 0.0.68

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naviedu/room-platform-react",
-  "version": "0.0.65",
+  "version": "0.0.68",
   "type": "module",
   "main": "./index.esm.js",
   "module": "./index.esm.js",
@@ -10,6 +10,10 @@
       "types": "./index.d.ts",
       "import": "./index.esm.js"
     },
+    "./room-control": {
+      "types": "./room-control.d.ts",
+      "import": "./room-control.esm.js"
+    },
     "./styles.css": "./styles.css"
   },
   "sideEffects": [

package/room-control.d.ts

@@ -0,0 +1,94 @@
+export declare type ClickPayload = {
+    x: number;
+    y: number;
+};
+
+export declare type ControlCommand<TPayload = unknown> = {
+    type: 'control-command';
+    version: typeof ROOM_CONTROL_VERSION;
+    scopeId: string;
+    commandId: string;
+    targetId?: string;
+    action: RoomControlAction;
+    payload: TPayload;
+};
+
+export declare type ControlDiscover = {
+    type: 'control-discover';
+    version: typeof ROOM_CONTROL_VERSION;
+    scopeId: string;
+    requestId: string;
+};
+
+export declare type ControlMessage = ControlTargetReady | ControlDiscover | ControlCommand | ControlState;
+
+export declare type ControlState<TState = unknown> = {
+    type: 'control-state';
+    version: typeof ROOM_CONTROL_VERSION;
+    scopeId: string;
+    targetId: string;
+    commandId?: string;
+    state?: TState;
+};
+
+export declare type ControlTargetReady = {
+    type: 'control-target-ready';
+    version: typeof ROOM_CONTROL_VERSION;
+    scopeId: string;
+    targetId: string;
+    targetType?: string;
+    capabilities: string[];
+    requestId?: string;
+};
+
+declare interface ControlTransport {
+    publish(message: unknown): void;
+    subscribe(handler: (message: unknown) => void): () => void;
+    close(): void;
+}
+
+export declare function createRoomControlTarget(options: RoomControlTargetOptions): RoomControlTarget;
+
+export declare function normalizeCapturedPoint({ clientX, clientY, contentRect, }: {
+    clientX: number;
+    clientY: number;
+    contentRect: Pick<DOMRect, 'left' | 'top' | 'width' | 'height'>;
+}): {
+    x: number;
+    y: number;
+} | null;
+
+export declare const ROOM_CONTROL_ACTIONS: {
+    readonly CLICK: "ui.click";
+    readonly SCROLL: "ui.scroll";
+};
+
+export declare const ROOM_CONTROL_VERSION: 1;
+
+export declare type RoomControlAction = (typeof ROOM_CONTROL_ACTIONS)[keyof typeof ROOM_CONTROL_ACTIONS];
+
+export declare type RoomControlTarget = {
+    readonly targetId: string;
+    close: () => void;
+};
+
+declare type RoomControlTargetHandlers = {
+    [action: string]: (payload: unknown) => void;
+};
+
+export declare type RoomControlTargetOptions = {
+    scopeId: string;
+    targetType?: string;
+    capabilities: readonly string[];
+    handlers: RoomControlTargetHandlers;
+    captureHandle?: {
+        roomOrigin?: string;
+    };
+    transport?: ControlTransport;
+};
+
+export declare type ScrollPayload = {
+    deltaY: number;
+};
+
+export { }

package/room-control.esm.js

@@ -0,0 +1,438 @@
+var ROOM_CONTROL_VERSION = 1;
+var ROOM_CONTROL_ACTIONS = {
+    CLICK: 'ui.click',
+    SCROLL: 'ui.scroll'
+};
+
+function normalizeCapturedPoint(param) {
+    var clientX = param.clientX, clientY = param.clientY, contentRect = param.contentRect;
+    if (!Number.isFinite(clientX) || !Number.isFinite(clientY) || !Number.isFinite(contentRect.left) || !Number.isFinite(contentRect.top) || !Number.isFinite(contentRect.width) || !Number.isFinite(contentRect.height) || contentRect.width <= 0 || contentRect.height <= 0) {
+        return null;
+    }
+    var x = (clientX - contentRect.left) / contentRect.width;
+    var y = (clientY - contentRect.top) / contentRect.height;
+    if (x < 0 || x > 1 || y < 0 || y > 1) return null;
+    return {
+        x: x,
+        y: y
+    };
+}
+
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+var MAX_CONTROL_SCOPE_LENGTH = 128;
+var MAX_CONTROL_ID_LENGTH = 128;
+var MAX_CONTROL_SCROLL_DELTA = 10000;
+var isRecord = function(value) {
+    return (typeof value === "undefined" ? "undefined" : _type_of(value)) === 'object' && value !== null && !Array.isArray(value);
+};
+var hasOwn = function(value, key) {
+    return Object.prototype.hasOwnProperty.call(value, key);
+};
+var hasRequiredOwn = function(value) {
+    for(var _len = arguments.length, keys = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
+        keys[_key - 1] = arguments[_key];
+    }
+    return keys.every(function(key) {
+        return hasOwn(value, key);
+    });
+};
+var isBoundedString = function(value, maxLength) {
+    return typeof value === 'string' && value === value.trim() && value.length > 0 && value.length <= maxLength;
+};
+var isValidId = function(value) {
+    return isBoundedString(value, MAX_CONTROL_ID_LENGTH);
+};
+var isValidScope = function(value) {
+    if (typeof value !== 'string') return false;
+    var normalized = normalizeScopeId(value);
+    return normalized !== null && normalized === value;
+};
+var isValidVersion = function(value) {
+    return value === ROOM_CONTROL_VERSION;
+};
+function normalizeScopeId(value) {
+    if (typeof value !== 'string') return null;
+    var normalized = value.trim();
+    return normalized.length > 0 && normalized.length <= MAX_CONTROL_SCOPE_LENGTH ? normalized : null;
+}
+function isValidScrollPayload(value) {
+    return isRecord(value) && hasRequiredOwn(value, 'deltaY') && typeof value.deltaY === 'number' && Number.isFinite(value.deltaY) && Math.abs(value.deltaY) <= MAX_CONTROL_SCROLL_DELTA;
+}
+function isValidClickPayload(value) {
+    return isRecord(value) && hasRequiredOwn(value, 'x', 'y') && typeof value.x === 'number' && typeof value.y === 'number' && Number.isFinite(value.x) && Number.isFinite(value.y) && value.x >= 0 && value.x <= 1 && value.y >= 0 && value.y <= 1;
+}
+function isValidControlPayload(action, payload) {
+    if (action === ROOM_CONTROL_ACTIONS.CLICK) return isValidClickPayload(payload);
+    if (action === ROOM_CONTROL_ACTIONS.SCROLL) return isValidScrollPayload(payload);
+    return false;
+}
+var isValidOptionalString = function(value, key) {
+    var maxLength = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : MAX_CONTROL_ID_LENGTH;
+    return !hasOwn(value, key) || isBoundedString(value[key], maxLength);
+};
+function isValidControlCommand(value) {
+    if (!isRecord(value) || !hasRequiredOwn(value, 'type', 'version', 'scopeId', 'commandId', 'action', 'payload')) {
+        return false;
+    }
+    if (value.type !== 'control-command' || !isValidVersion(value.version) || !isValidScope(value.scopeId) || !isValidId(value.commandId) || !isValidId(value.action) || !isValidControlPayload(value.action, value.payload)) {
+        return false;
+    }
+    return !hasOwn(value, 'targetId') || isValidId(value.targetId);
+}
+function isValidControlTargetReady(value) {
+    return hasRequiredOwn(value, 'type', 'version', 'scopeId', 'targetId', 'capabilities') && value.type === 'control-target-ready' && isValidVersion(value.version) && isValidScope(value.scopeId) && isValidId(value.targetId) && Array.isArray(value.capabilities) && value.capabilities.every(function(capability) {
+        return isBoundedString(capability, MAX_CONTROL_ID_LENGTH);
+    }) && isValidOptionalString(value, 'targetType') && isValidOptionalString(value, 'requestId');
+}
+function isValidControlDiscover(value) {
+    return hasRequiredOwn(value, 'type', 'version', 'scopeId', 'requestId') && value.type === 'control-discover' && isValidVersion(value.version) && isValidScope(value.scopeId) && isValidId(value.requestId);
+}
+function isValidControlState(value) {
+    return hasRequiredOwn(value, 'type', 'version', 'scopeId', 'targetId') && value.type === 'control-state' && isValidVersion(value.version) && isValidScope(value.scopeId) && isValidId(value.targetId) && isValidOptionalString(value, 'commandId');
+}
+function isValidControlMessage(value) {
+    if (!isRecord(value) || !hasOwn(value, 'type')) return false;
+    if (value.type === 'control-command') return isValidControlCommand(value);
+    if (value.type === 'control-target-ready') return isValidControlTargetReady(value);
+    if (value.type === 'control-discover') return isValidControlDiscover(value);
+    if (value.type === 'control-state') return isValidControlState(value);
+    return false;
+}
+
+function controlChannelName(scopeId) {
+    var normalizedScopeId = normalizeScopeId(scopeId);
+    return normalizedScopeId === null ? '' : "naviedu:room-control:v".concat(ROOM_CONTROL_VERSION, ":").concat(normalizedScopeId);
+}
+function createBroadcastChannelTransport(scopeId) {
+    var normalizedScopeId = normalizeScopeId(scopeId);
+    if (normalizedScopeId === null || typeof window === 'undefined') return null;
+    try {
+        if (typeof window.BroadcastChannel !== 'function') return null;
+        var channel = new window.BroadcastChannel(controlChannelName(normalizedScopeId));
+        var handlers = new Set();
+        var closed = false;
+        channel.onmessage = function(event) {
+            if (closed) return;
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                for(var _iterator = handlers[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                    var handler = _step.value;
+                    try {
+                        handler(event.data);
+                    } catch (unused) {
+                    // A subscriber must not break delivery to other subscribers.
+                    }
+                }
+            } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+        };
+        return {
+            publish: function publish(message) {
+                if (closed) return;
+                try {
+                    channel.postMessage(message);
+                } catch (unused) {
+                // Unsupported structured-clone values are intentionally ignored.
+                }
+            },
+            subscribe: function subscribe(handler) {
+                if (closed) return function() {
+                    return undefined;
+                };
+                handlers.add(handler);
+                return function() {
+                    return handlers.delete(handler);
+                };
+            },
+            close: function close() {
+                if (closed) return;
+                closed = true;
+                handlers.clear();
+                try {
+                    channel.onmessage = null;
+                    channel.close();
+                } catch (unused) {
+                // Closing an already-broken native channel is a no-op.
+                }
+            }
+        };
+    } catch (unused) {
+        return null;
+    }
+}
+
+function encodeRoomControlCaptureHandle(handle) {
+    return JSON.stringify(handle);
+}
+function getCaptureHandleSetter() {
+    try {
+        if (typeof navigator === 'undefined' || !navigator.mediaDevices) return null;
+        var mediaDevices = navigator.mediaDevices;
+        var setCaptureHandleConfig = mediaDevices.setCaptureHandleConfig;
+        return typeof setCaptureHandleConfig === 'function' ? {
+            mediaDevices: mediaDevices,
+            setCaptureHandleConfig: setCaptureHandleConfig
+        } : null;
+    } catch (unused) {
+        return null;
+    }
+}
+function exactOrigin(roomOrigin) {
+    var origin = roomOrigin !== null && roomOrigin !== void 0 ? roomOrigin : typeof window === 'undefined' ? undefined : window.location.origin;
+    if (!origin || origin === 'null') return null;
+    try {
+        return new URL(origin).origin === origin ? origin : null;
+    } catch (unused) {
+        return null;
+    }
+}
+function registerRoomControlCaptureHandle(handle, roomOrigin) {
+    var setter = getCaptureHandleSetter();
+    var permittedOrigin = exactOrigin(roomOrigin);
+    if (setter === null || permittedOrigin === null) return function() {
+        return undefined;
+    };
+    try {
+        setter.setCaptureHandleConfig.call(setter.mediaDevices, {
+            handle: encodeRoomControlCaptureHandle(handle),
+            permittedOrigins: [
+                permittedOrigin
+            ]
+        });
+    } catch (unused) {
+    // Capture Handle is optional and must not break target startup.
+    }
+    return function() {
+        try {
+            setter.setCaptureHandleConfig.call(setter.mediaDevices, {
+                handle: '',
+                permittedOrigins: []
+            });
+        } catch (unused) {
+        // Cleanup is best effort because the browser API is optional.
+        }
+    };
+}
+
+function storageKey(scopeId) {
+    var normalizedScopeId = normalizeScopeId(scopeId);
+    return normalizedScopeId === null ? null : "naviedu:room-control:v".concat(ROOM_CONTROL_VERSION, ":target-id:").concat(encodeURIComponent(normalizedScopeId));
+}
+function getSessionStorage() {
+    if (typeof window === 'undefined') return null;
+    try {
+        return window.sessionStorage;
+    } catch (unused) {
+        return null;
+    }
+}
+function generateTargetId() {
+    try {
+        var _globalThis_crypto;
+        var randomUUID = (_globalThis_crypto = globalThis.crypto) === null || _globalThis_crypto === void 0 ? void 0 : _globalThis_crypto.randomUUID;
+        if (typeof randomUUID === 'function') {
+            var targetId = randomUUID.call(globalThis.crypto);
+            if (targetId) return targetId;
+        }
+    } catch (unused) {
+    // Fall through to a non-empty local ID.
+    }
+    return "target-".concat(Date.now().toString(36), "-").concat(Math.random().toString(36).slice(2));
+}
+function createTargetId(scopeId) {
+    var targetId = generateTargetId();
+    var key = storageKey(scopeId);
+    var storage = key === null ? null : getSessionStorage();
+    if (storage !== null && key !== null) {
+        try {
+            storage.setItem(key, targetId);
+        } catch (unused) {
+        // sessionStorage may be unavailable or quota-limited.
+        }
+    }
+    return targetId;
+}
+function restoreTargetId(scopeId) {
+    var key = storageKey(scopeId);
+    var storage = key === null ? null : getSessionStorage();
+    if (storage !== null && key !== null) {
+        try {
+            var targetId = storage.getItem(key);
+            if (targetId) return targetId;
+        } catch (unused) {
+        // Generate an in-memory ID when sessionStorage is unavailable.
+        }
+    }
+    return createTargetId(scopeId);
+}
+
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+var isValidTargetId = function(value) {
+    return typeof value === 'string' && value === value.trim() && value.length > 0 && value.length <= MAX_CONTROL_ID_LENGTH;
+};
+function createRoomControlTarget(options) {
+    var _options_transport;
+    var scopeId = normalizeScopeId(options.scopeId);
+    if (scopeId === null) throw new Error('Invalid room-control scope');
+    var restoredTargetId = restoreTargetId(scopeId);
+    var targetId = isValidTargetId(restoredTargetId) ? restoredTargetId : createTargetId(scopeId);
+    var capabilities = _to_consumable_array(options.capabilities);
+    var supportedCapabilities = new Set(capabilities);
+    var transport = (_options_transport = options.transport) !== null && _options_transport !== void 0 ? _options_transport : createBroadcastChannelTransport(scopeId);
+    var closed = false;
+    var publishReady = function(requestId) {
+        if (transport === null || closed) return;
+        var ready = _object_spread(_object_spread_props(_object_spread({
+            type: 'control-target-ready',
+            version: ROOM_CONTROL_VERSION,
+            scopeId: scopeId,
+            targetId: targetId
+        }, options.targetType === undefined ? {} : {
+            targetType: options.targetType
+        }), {
+            capabilities: capabilities
+        }), requestId === undefined ? {} : {
+            requestId: requestId
+        });
+        transport.publish(ready);
+    };
+    var handleMessage = function(message) {
+        if (closed || !isValidControlMessage(message) || message.scopeId !== scopeId) return;
+        if (message.type === 'control-discover') {
+            publishReady(message.requestId);
+            return;
+        }
+        if (message.type !== 'control-command') return;
+        if (message.targetId !== undefined && message.targetId !== targetId) return;
+        if (!supportedCapabilities.has(message.action)) return;
+        var handler = options.handlers[message.action];
+        if (typeof handler !== 'function') return;
+        try {
+            handler(message.payload);
+        } catch (unused) {
+        // An adapter failure must not break discovery or later commands.
+        }
+    };
+    var unsubscribe = transport === null ? function() {
+        return undefined;
+    } : transport.subscribe(handleMessage);
+    var cleanupCaptureHandle = options.captureHandle ? registerRoomControlCaptureHandle({
+        version: ROOM_CONTROL_VERSION,
+        scopeId: scopeId,
+        targetId: targetId
+    }, options.captureHandle.roomOrigin) : function() {
+        return undefined;
+    };
+    publishReady();
+    return {
+        targetId: targetId,
+        close: function close() {
+            if (closed) return;
+            closed = true;
+            try {
+                cleanupCaptureHandle();
+            } catch (unused) {
+            // Capture Handle cleanup is best effort.
+            }
+            try {
+                unsubscribe();
+            } catch (unused) {
+            // A broken transport subscription must not block other cleanup.
+            }
+            if (transport === null) return;
+            try {
+                transport.close();
+            } catch (unused) {
+            // A broken transport must not escape target cleanup.
+            }
+        }
+    };
+}
+
+export { ROOM_CONTROL_ACTIONS, ROOM_CONTROL_VERSION, createRoomControlTarget, normalizeCapturedPoint };