@clockworkdog/cogs-client 3.1.3 → 3.2.0

package/dist/helpers/urls.d.ts

@@ -0,0 +1,6 @@
+export declare const COGS_SERVER_PORT = 12095;
+/**
+ * Get the URL of an asset hosted by the COGS server.
+ */
+export declare function assetUrl(file: string): string;
+export declare function preloadUrl(url: string): Promise<string>;

package/dist/helpers/urls.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COGS_SERVER_PORT = void 0;
+exports.assetUrl = assetUrl;
+exports.preloadUrl = preloadUrl;
+exports.COGS_SERVER_PORT = 12095;
+/**
+ * Get the URL of an asset hosted by the COGS server.
+ */
+function assetUrl(file) {
+    const location = typeof window !== 'undefined' ? window.location : undefined;
+    const path = `/assets/${encodeURIComponent(file)}`;
+    return `${location === null || location === void 0 ? void 0 : location.protocol}//${location === null || location === void 0 ? void 0 : location.hostname}:${exports.COGS_SERVER_PORT}${path}`;
+}
+async function preloadUrl(url) {
+    const response = await fetch(url);
+    // We used arrayBuffer()` instead of `blob()` because the latter seems to fail on Pis when preloading some files
+    return URL.createObjectURL(new Blob([await response.arrayBuffer()]));
+}

package/dist/types/AllMediaClipStatesMessage.d.ts

@@ -0,0 +1,5 @@
+export type MediaStatus = 'playing' | 'paused' | 'stopped';
+export default interface AllMediaClipStatesMessage {
+    mediaType: 'audio' | 'video';
+    files: [string, MediaStatus][];
+}

package/dist/types/AllMediaClipStatesMessage.js

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

package/dist/types/AudioState.d.ts

@@ -0,0 +1,39 @@
+export type ActiveAudioClipState = {
+    type: 'paused';
+} | {
+    type: 'pause_requested';
+    fade: number | undefined;
+} | {
+    type: 'pausing';
+} | {
+    type: 'playing';
+} | {
+    type: 'play_requested';
+} | {
+    type: 'stopping';
+} | {
+    type: 'stop_requested';
+    fade: number | undefined;
+};
+export interface AudioClip {
+    config: {
+        preload: boolean;
+        ephemeral: boolean;
+    };
+    activeClips: {
+        [soundId: number]: ActiveClip;
+    };
+}
+export interface ActiveClip {
+    state: ActiveAudioClipState;
+    loop: boolean;
+    volume: number;
+    playId: string;
+}
+export interface AudioState {
+    isPlaying: boolean;
+    globalVolume: number;
+    clips: {
+        [path: string]: AudioClip;
+    };
+}

package/dist/types/AudioState.js

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

package/dist/types/MediaClipStateMessage.d.ts

@@ -0,0 +1,7 @@
+export type MediaStatus = 'playing' | 'paused' | 'stopped';
+export default interface MediaClipStateMessage {
+    playId: string;
+    mediaType: 'audio' | 'video';
+    file: string;
+    status: MediaStatus;
+}

package/dist/types/MediaClipStateMessage.js

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

package/dist/types/VideoState.d.ts

@@ -0,0 +1,26 @@
+import { MediaObjectFit } from '..';
+export declare enum ActiveVideoClipState {
+    Paused = "paused",
+    Playing = "playing"
+}
+export interface VideoClip {
+    config: {
+        preload: 'auto' | 'metadata' | 'none';
+        ephemeral: boolean;
+        fit: MediaObjectFit;
+    };
+}
+export interface ActiveClip {
+    path: string;
+    state: ActiveVideoClipState;
+    loop: boolean;
+    volume: number;
+}
+export interface VideoState {
+    isPlaying: boolean;
+    globalVolume: number;
+    clips: {
+        [path: string]: VideoClip;
+    };
+    activeClip?: ActiveClip;
+}

package/dist/types/VideoState.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActiveVideoClipState = void 0;
+var ActiveVideoClipState;
+(function (ActiveVideoClipState) {
+    ActiveVideoClipState["Paused"] = "paused";
+    ActiveVideoClipState["Playing"] = "playing";
+})(ActiveVideoClipState || (exports.ActiveVideoClipState = ActiveVideoClipState = {}));

package/dist/utils/NetworkHostPattern.d.ts

@@ -11,5 +11,6 @@ export declare class NetworkHostPattern {
     constructor(pattern: string);
     /** Checks whether `host` and `port` are matched by this pattern. */
     validate(host: string, port: number): boolean;
-    private matchesHost;
+    /** Checks whether `host` is matched by the hostname part of this pattern, ignoring the port. */
+    validateHostname(host: string): boolean;
 }

package/dist/utils/NetworkHostPattern.js

@@ -23,9 +23,10 @@ export class NetworkHostPattern {
     }
     /** Checks whether `host` and `port` are matched by this pattern. */
     validate(host, port) {
-        return this.matchesHost(host) && (this.port === '*' || Number(this.port) === port);
+        return this.validateHostname(host) && (this.port === '*' || Number(this.port) === port);
     }
-    matchesHost(host) {
+    /** Checks whether `host` is matched by the hostname part of this pattern, ignoring the port. */
+    validateHostname(host) {
         // Hostnames are case-insensitive; IP literals are unaffected by lowercasing.
         const patternHost = this.host.toLowerCase();
         host = host.toLowerCase();

package/dist/utils/getPluginManifestErrors.js

@@ -130,7 +130,7 @@ function createManifestSchema(objectSchemaFactory) {
                 access: z
                     .array(objectSchemaFactory({
                     hosts: z.array(z.string().refine(validateNetworkHostPattern, { error: 'Invalid network host pattern' })).min(1),
-                    caCertificate: z.string().optional(),
+                    caCertificates: z.array(z.string().min(1)).optional(),
                 }))
                     .optional(),
             })

package/dist/utils/setDate.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Patch `Date.now()` and `new Date()` given the current time is @param now
+ */
+export declare function setDate(now: number): void;

package/dist/utils/setDate.js

@@ -0,0 +1,26 @@
+"use strict";
+// Adapted from https://stackoverflow.com/a/58325977/244640
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setDate = setDate;
+const OriginalDateConstructor = globalThis.Date;
+/**
+ * Patch `Date.now()` and `new Date()` given the current time is @param now
+ */
+function setDate(now) {
+    const nowDelta = now - OriginalDateConstructor.now();
+    function Date(...args) {
+        if (args.length === 0) {
+            return new OriginalDateConstructor(Date.now()); // Date.now() is implemented below
+        }
+        // Specific date constructor
+        return new OriginalDateConstructor(...args);
+    }
+    // copy all properties from the original date, this includes the prototype
+    const propertyDescriptors = Object.getOwnPropertyDescriptors(OriginalDateConstructor);
+    Object.defineProperties(Date, propertyDescriptors);
+    // override Date.now to return the adjusted time
+    Date.now = function () {
+        return OriginalDateConstructor.now() + nowDelta;
+    };
+    globalThis.Date = Date;
+}

package/dist/utils/timesync.d.ts

@@ -0,0 +1,28 @@
+export interface TimeSyncRequestData {
+    timesync: {
+        id: number;
+    };
+}
+export interface TimeSyncResponseData {
+    timesync: {
+        id: number;
+        now: number;
+    };
+}
+export interface TimeSyncClient {
+    receive(data: TimeSyncResponseData): void;
+    destroy(): void;
+}
+export interface TimeSyncServer {
+    receive(data: TimeSyncRequestData): void;
+}
+export declare function createTimeSyncClient({ interval, send, onChange, syncSampleSize, syncRequestTimeout, }: {
+    interval: number;
+    send: (data: TimeSyncRequestData) => void | Promise<void>;
+    onChange?: (now: number) => void;
+    syncSampleSize?: number;
+    syncRequestTimeout?: number;
+}): TimeSyncClient;
+export declare function createTimeSyncServer({ send }: {
+    send: (data: TimeSyncResponseData) => void | Promise<void>;
+}): TimeSyncServer;

package/dist/utils/timesync.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTimeSyncClient = createTimeSyncClient;
+exports.createTimeSyncServer = createTimeSyncServer;
+const setDate_1 = require("./setDate");
+let id = 0;
+function getId() {
+    return ++id;
+}
+const SYNC_SAMPLE_SIZE = 5;
+const SYNC_REQUEST_TIMEOUT = 10000;
+function createTimeSyncClient({ interval, send, onChange = setDate_1.setDate, syncSampleSize = SYNC_SAMPLE_SIZE, syncRequestTimeout = SYNC_REQUEST_TIMEOUT, }) {
+    const requests = {};
+    async function synchronize() {
+        const promises = [];
+        // Send a series of requests
+        for (let i = 0; i < syncSampleSize; i++) {
+            const promise = new Promise((resolve) => {
+                const id = getId();
+                const sentAt = performance.now();
+                send({ timesync: { id } });
+                const complete = (receivedAt, serverNow) => resolve({ sentAt, receivedAt, serverNow, clientNow: Date.now() });
+                requests[id] = { complete };
+                setTimeout(() => resolve(null), syncRequestTimeout);
+            });
+            promises.push(promise);
+            await promise;
+        }
+        // Perform calculation with results
+        const results = await Promise.all(promises);
+        const deltas = results
+            .filter((result) => result !== null)
+            .map((result) => {
+            const { sentAt, receivedAt, serverNow, clientNow } = result;
+            const halfLatency = (receivedAt - sentAt) / 2;
+            return clientNow - serverNow + halfLatency;
+        });
+        const averageDelta = deltas.reduce((d1, d2) => d1 + d2, 0) / deltas.length;
+        if (!isNaN(averageDelta)) {
+            onChange(Date.now() + averageDelta);
+        }
+    }
+    const receive = (data) => {
+        const receivedAt = performance.now();
+        const req = requests[data.timesync.id];
+        if (!req)
+            return;
+        req.complete(receivedAt, data.timesync.now);
+    };
+    synchronize();
+    const loop = setInterval(synchronize, interval);
+    const destroy = () => {
+        clearInterval(loop);
+    };
+    return {
+        receive,
+        destroy,
+    };
+}
+function createTimeSyncServer({ send }) {
+    return {
+        receive(data) {
+            const { id } = data.timesync;
+            send({ timesync: { id, now: Date.now() } });
+        },
+    };
+}

package/package.json

@@ -3,7 +3,7 @@
   "description": "Connect to COGS to build a custom Media Master",
   "author": "Clockwork Dog <info@clockwork.dog>",
   "homepage": "https://github.com/clockwork-dog/cogs-sdk/tree/main/packages/javascript",
-  "version": "3.1.3",
+  "version": "3.2.0",
   "keywords": [],
   "license": "MIT",
   "repository": {
@@ -37,7 +37,7 @@
     "cy:generate": "cypress run --e2e"
   },
   "dependencies": {
-    "@clockworkdog/timesync": "^3.1.3",
+    "@clockworkdog/timesync": "^3.2.0",
     "ip-address": "^10.2.0",
     "reconnecting-websocket": "^4.4.0",
     "semver": "^7.8.5",