@akashic/headless-driver 2.6.2 → 2.7.0

package/lib/play/AMFlowClientManager.d.ts

@@ -1,10 +1,17 @@
 import type { Permission } from "@akashic/amflow";
 import { AMFlowClient } from "./amflow/AMFlowClient";
+import type { AMFlowStoreOptions } from "./amflow/AMFlowStore";
 export declare class AMFlowClientManager {
     /**
      * PlayId と AMFlowStore を紐付けるマップ情報。
      */
     private storeMap;
+    /**
+     * 対象の PlayID の オプションを設定する。
+     * @param playId PlayID
+     * @param options オプション
+     */
+    setAMFlowStoreOptions(playId: string, options: AMFlowStoreOptions | null): void;
     /**
      * 対象の PlayID の AMFlowClient を作成する。
      * @param playId PlayID

package/lib/play/AMFlowClientManager.js

@@ -10,6 +10,18 @@ class AMFlowClientManager {
          */
         this.storeMap = new Map();
     }
+    /**
+     * 対象の PlayID の オプションを設定する。
+     * @param playId PlayID
+     * @param options オプション
+     */
+    setAMFlowStoreOptions(playId, options) {
+        let store = this.storeMap.get(playId);
+        if (!store) {
+            store = this.createAMFlowStore(playId);
+        }
+        store.setOptions(options);
+    }
     /**
      * 対象の PlayID の AMFlowClient を作成する。
      * @param playId PlayID

package/lib/play/PlayManager.d.ts

@@ -1,4 +1,5 @@
 import type { Permission } from "@akashic/amflow";
+import type { AMFlowStoreOptions } from "./amflow";
 import type { AMFlowClient } from "./amflow/AMFlowClient";
 import type { DumpedPlaylog } from "./amflow/types";
 import type { ContentLocation } from "./Content";
@@ -18,7 +19,7 @@ export declare class PlayManager {
      * Play を作成する。
      * @param playLocation パラメータ
      */
-    createPlay(playLocation: PlayManagerParameters, playlog?: DumpedPlaylog): Promise<string>;
+    createPlay(playLocation: PlayManagerParameters, playlog?: DumpedPlaylog, options?: AMFlowStoreOptions): Promise<string>;
     /**
      * Play を削除する。
      * @param playID PlayID

package/lib/play/PlayManager.js

@@ -24,10 +24,12 @@ class PlayManager {
      * Play を作成する。
      * @param playLocation パラメータ
      */
-    createPlay(playLocation, playlog) {
+    createPlay(playLocation, playlog, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const playId = `${this.nextPlayId++}`;
             this.plays.push(Object.assign({ playId, status: "running", createdAt: Date.now(), lastSuspendedAt: null }, playLocation));
+            if (options)
+                this.amflowClientManager.setAMFlowStoreOptions(playId, options);
             if (playlog) {
                 const amflow = this.createAMFlow(playId);
                 amflow.setDumpedPlaylog(playlog);

package/lib/play/amflow/AMFlowClient.d.ts

@@ -15,7 +15,7 @@ export declare class AMFlowClient implements AMFlow {
     private permission;
     private tickHandlers;
     private eventHandlers;
-    private unconsumedEvents;
+    private waitingStartPointRequests;
     constructor(playId: string, store: AMFlowStore);
     open(playId: string, callback?: (error: Error | null) => void): void;
     close(callback?: (error: Error | null) => void): void;

package/lib/play/amflow/AMFlowClient.js

@@ -14,14 +14,39 @@ class AMFlowClient {
         this.permission = null;
         this.tickHandlers = [];
         this.eventHandlers = [];
-        this.unconsumedEvents = [];
+        this.waitingStartPointRequests = [];
+        this.handleSendTick = (tick) => {
+            this.tickHandlers.forEach((h) => h(tick));
+        };
+        this.handleSendEvent = (event) => {
+            this.eventHandlers.forEach((h) => h(event));
+        };
+        this.handlePutStartPoint = (startPoint) => {
+            this.onPutStartPoint.fire(startPoint);
+            if (this.waitingStartPointRequests.length) {
+                const remains = [];
+                this.waitingStartPointRequests.forEach((req) => {
+                    const { frame, timestamp } = req.options;
+                    if ((frame != null && startPoint.frame <= frame) ||
+                        (timestamp != null && startPoint.timestamp < timestamp) ||
+                        (frame == null && timestamp == null && startPoint.frame === 0)) {
+                        req.callback(null, startPoint);
+                        return;
+                    }
+                    if (startPoint.frame === 0) {
+                        req.callback((0, ErrorFactory_1.createError)("bad_request"));
+                        return;
+                    }
+                    remains.push(req);
+                });
+                this.waitingStartPointRequests = remains;
+            }
+        };
         this.playId = playId;
         this.store = store;
     }
     open(playId, callback) {
         (0, Logger_1.getSystemLogger)().info("AMFlowClient#open()", playId);
-        this.store.sendEventTrigger.add(this.handleSendEvent, this);
-        this.store.sendTickTrigger.add(this.handleSendTick, this);
         this.store.putStartPointTrigger.add(this.handlePutStartPoint, this);
         this.state = "open";
         if (callback) {
@@ -101,6 +126,8 @@ class AMFlowClient {
             throw (0, ErrorFactory_1.createError)("permission_error", "Permission denied");
         }
         this.tickHandlers.push(handler);
+        if (this.tickHandlers.length === 1)
+            this.store.onTick(this.handleSendTick);
     }
     offTick(handler) {
         if (this.state !== "open") {
@@ -110,6 +137,8 @@ class AMFlowClient {
             throw (0, ErrorFactory_1.createError)("invalid_status", "Not authenticated");
         }
         this.tickHandlers = this.tickHandlers.filter((h) => h !== handler);
+        if (this.tickHandlers.length === 0)
+            this.store.offTick(this.handleSendTick);
     }
     sendEvent(event) {
         if (this.state !== "open") {
@@ -138,12 +167,8 @@ class AMFlowClient {
             throw (0, ErrorFactory_1.createError)("permission_error", "Permission denied");
         }
         this.eventHandlers.push(handler);
-        if (0 < this.unconsumedEvents.length) {
-            this.eventHandlers.forEach((h) => {
-                this.unconsumedEvents.forEach((ev) => h(ev));
-            });
-            this.unconsumedEvents = [];
-        }
+        if (this.eventHandlers.length === 1)
+            this.store.onEvent(this.handleSendEvent);
     }
     offEvent(handler) {
         if (this.state !== "open") {
@@ -153,6 +178,8 @@ class AMFlowClient {
             throw (0, ErrorFactory_1.createError)("invalid_status", "Not authenticated");
         }
         this.eventHandlers = this.eventHandlers.filter((h) => h !== handler);
+        if (this.eventHandlers.length === 0)
+            this.store.offEvent(this.handleSendEvent);
     }
     getTickList(optsOrBegin, endOrCallback, callbackOrUndefined) {
         setImmediate(() => {
@@ -229,12 +256,11 @@ class AMFlowClient {
                 return;
             }
             const startPoint = this.store.getStartPoint(opts);
-            if (startPoint) {
-                callback(null, startPoint);
-            }
-            else {
-                callback((0, ErrorFactory_1.createError)("runtime_error", "No start point"), undefined);
+            if (!startPoint) {
+                this.waitingStartPointRequests.push({ options: opts, callback });
+                return;
             }
+            callback(null, startPoint);
         });
     }
     /* eslint-disable @typescript-eslint/no-unused-vars */
@@ -258,15 +284,15 @@ class AMFlowClient {
             return;
         }
         if (!this.store.isDestroyed()) {
-            this.store.sendEventTrigger.remove(this.handleSendEvent, this);
-            this.store.sendTickTrigger.remove(this.handleSendTick, this);
+            this.store.offEvent(this.handleSendEvent);
+            this.store.offTick(this.handleSendTick);
             this.store.putStartPointTrigger.remove(this.handlePutStartPoint, this);
         }
         this.store = null;
         this.permission = null;
         this.tickHandlers = null;
         this.eventHandlers = null;
-        this.unconsumedEvents = null;
+        this.waitingStartPointRequests = null;
         this.onPutStartPoint = null;
     }
     isDestroyed() {
@@ -275,18 +301,5 @@ class AMFlowClient {
     dump() {
         return this.store.dump();
     }
-    handleSendTick(tick) {
-        this.tickHandlers.forEach((h) => h(tick));
-    }
-    handleSendEvent(event) {
-        if (this.eventHandlers.length <= 0) {
-            this.unconsumedEvents.push(event);
-            return;
-        }
-        this.eventHandlers.forEach((h) => h(event));
-    }
-    handlePutStartPoint(startPoint) {
-        this.onPutStartPoint.fire(startPoint);
-    }
 }
 exports.AMFlowClient = AMFlowClient;

package/lib/play/amflow/AMFlowStore.d.ts

@@ -2,24 +2,40 @@ import type { GetStartPointOptions, GetTickListOptions, Permission, StartPoint }
 import type { Event, Tick, TickList } from "@akashic/playlog";
 import { Trigger } from "@akashic/trigger";
 import type { DumpedPlaylog } from "./types";
+export interface AMFlowStoreOptions {
+    /**
+     * 受信されないイベントをバッファリングするか。
+     *
+     * 真の場合、受信者が一つもない状態で送信されたイベントをバッファに保持する。
+     * 保持されたイベントは、最初のイベントハンドラが (AMFlow#onEvent() で) 登録された時、そのハンドラにすべて引き渡される。
+     * (二つ目以降のハンドラは受け取れないことに注意)
+     */
+    preservesUnhandledEvents?: boolean;
+}
 /**
  * AMFlow のストア。
  * 一つのプレーに対して一つ存在する。
  */
 export declare class AMFlowStore {
     playId: string;
+    putStartPointTrigger: Trigger<StartPoint>;
     sendEventTrigger: Trigger<Event>;
     sendTickTrigger: Trigger<Tick>;
-    putStartPointTrigger: Trigger<StartPoint>;
     private permissionMap;
     private startPoints;
     private unfilteredTickList;
     private filteredTickList;
     private suspended;
+    private options;
+    private unhandledEvents;
     constructor(playId: string);
     authenticate(token: string, revoke?: boolean): Permission;
     sendTick(tick: Tick): void;
     sendEvent(event: Event): void;
+    onTick(handler: (tick: Tick) => void): void;
+    offTick(handler: (tick: Tick) => void): void;
+    onEvent(handler: (event: Event) => void): void;
+    offEvent(handler: (event: Event) => void): void;
     getTickList(opts: GetTickListOptions): TickList | null;
     putStartPoint(startPoint: StartPoint): void;
     getStartPoint(opts: GetStartPointOptions): StartPoint | null;
@@ -41,6 +57,7 @@ export declare class AMFlowStore {
     resume(): void;
     setTickList(tickList: TickList | null): void;
     setDumpedPlaylog(dumped: DumpedPlaylog): void;
+    setOptions(options: AMFlowStoreOptions | null): void;
     destroy(): void;
     isDestroyed(): boolean;
     createPlayToken(permission: Permission): string;

package/lib/play/amflow/AMFlowStore.js

@@ -11,13 +11,16 @@ const ErrorFactory_1 = require("./ErrorFactory");
  */
 class AMFlowStore {
     constructor(playId) {
+        this.putStartPointTrigger = new trigger_1.Trigger();
+        // 現状外部から参照する必要はないが、互換性のため少なくとも 2.x.x の間は公開する
         this.sendEventTrigger = new trigger_1.Trigger();
         this.sendTickTrigger = new trigger_1.Trigger();
-        this.putStartPointTrigger = new trigger_1.Trigger();
         this.permissionMap = new Map();
         this.startPoints = [];
         this.unfilteredTickList = null;
         this.filteredTickList = null;
+        this.options = null;
+        this.unhandledEvents = [];
         this.playId = playId;
         this.suspended = false;
     }
@@ -39,10 +42,32 @@ class AMFlowStore {
         this.sendTickTrigger.fire(tick);
     }
     sendEvent(event) {
+        var _a;
         if (this.isSuspended()) {
             throw (0, ErrorFactory_1.createError)("bad_request", "Play may be suspended");
         }
-        this.sendEventTrigger.fire(this.cloneDeep(event));
+        const ev = this.cloneDeep(event);
+        if (((_a = this.options) === null || _a === void 0 ? void 0 : _a.preservesUnhandledEvents) && this.sendEventTrigger.length === 0) {
+            this.unhandledEvents.push(ev);
+            return;
+        }
+        this.sendEventTrigger.fire(ev);
+    }
+    onTick(handler) {
+        this.sendTickTrigger.add(handler);
+    }
+    offTick(handler) {
+        this.sendTickTrigger.remove(handler);
+    }
+    onEvent(handler) {
+        this.sendEventTrigger.add(handler);
+        if (0 < this.unhandledEvents.length) {
+            this.unhandledEvents.forEach((ev) => this.sendEventTrigger.fire(ev));
+            this.unhandledEvents = [];
+        }
+    }
+    offEvent(handler) {
+        this.sendEventTrigger.remove(handler);
     }
     getTickList(opts) {
         if (!(this.unfilteredTickList && this.filteredTickList)) {
@@ -133,6 +158,9 @@ class AMFlowStore {
         this.setTickList(dumped.tickList);
         dumped.startPoints.forEach((sp) => this.putStartPoint(sp));
     }
+    setOptions(options) {
+        this.options = options;
+    }
     destroy() {
         if (this.isDestroyed()) {
             return;
@@ -143,6 +171,7 @@ class AMFlowStore {
         this.sendTickTrigger = null;
         this.permissionMap = null;
         this.startPoints = null;
+        this.unhandledEvents = null;
         this.putStartPointTrigger = null;
     }
     isDestroyed() {

package/lib/utils.d.ts

@@ -2,7 +2,19 @@
  * ファイルを読み込む。
  *
  * @param url url または path
- * @param opt オプション
  */
 export declare function loadFile(url: string): Promise<string>;
+/**
+ * loadFile() の内部実装のうち、特にテストのため外部から参照するものをまとめた namespace 。
+ * 通常の利用では参照する必要はない。
+ */
+export declare namespace LoadFileInternal {
+    /**
+     * 最大並列ロード数。
+     * 環境によって、node-fetch を一定数以上並列に実行すると応答がなくなったりエラーになる場合がある。
+     * 具体的な値は調整の余地がある。少なくとも Windows 環境で、128 以上で問題が起きることがわかっている。
+     */
+    const MAX_PARALLEL_LOAD = 32;
+    function loadImpl(url: string): Promise<string>;
+}
 export declare function isHttpProtocol(url: string): boolean;

package/lib/utils.js

@@ -9,28 +9,70 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isHttpProtocol = exports.loadFile = void 0;
+exports.isHttpProtocol = exports.LoadFileInternal = exports.loadFile = void 0;
 const fs = require("fs");
 const node_fetch_1 = require("node-fetch");
+const waitings = [];
+let loadingCount = 0;
 /**
  * ファイルを読み込む。
  *
  * @param url url または path
- * @param opt オプション
  */
 function loadFile(url) {
     return __awaiter(this, void 0, void 0, function* () {
-        if (isHttpProtocol(url)) {
-            const res = yield (0, node_fetch_1.default)(url, { method: "GET" });
-            return res.text();
+        const promise = new Promise((resolve, reject) => {
+            waitings.push({ url, resolve, reject });
+        });
+        processWaitingLoad();
+        return promise;
+    });
+}
+exports.loadFile = loadFile;
+function processWaitingLoad() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (loadingCount >= LoadFileInternal.MAX_PARALLEL_LOAD || waitings.length === 0)
+            return;
+        const { url, resolve, reject } = waitings.shift();
+        try {
+            ++loadingCount;
+            resolve(yield LoadFileInternal.loadImpl(url));
         }
-        else {
-            const str = fs.readFileSync(url, { encoding: "utf8" });
-            return str;
+        catch (e) {
+            reject(e);
+        }
+        finally {
+            --loadingCount;
+            processWaitingLoad();
         }
     });
 }
-exports.loadFile = loadFile;
+/**
+ * loadFile() の内部実装のうち、特にテストのため外部から参照するものをまとめた namespace 。
+ * 通常の利用では参照する必要はない。
+ */
+var LoadFileInternal;
+(function (LoadFileInternal) {
+    /**
+     * 最大並列ロード数。
+     * 環境によって、node-fetch を一定数以上並列に実行すると応答がなくなったりエラーになる場合がある。
+     * 具体的な値は調整の余地がある。少なくとも Windows 環境で、128 以上で問題が起きることがわかっている。
+     */
+    LoadFileInternal.MAX_PARALLEL_LOAD = 32;
+    function loadImpl(url) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (isHttpProtocol(url)) {
+                const res = yield (0, node_fetch_1.default)(url, { method: "GET" });
+                return res.text();
+            }
+            else {
+                const str = fs.readFileSync(url, { encoding: "utf8" });
+                return str;
+            }
+        });
+    }
+    LoadFileInternal.loadImpl = loadImpl;
+})(LoadFileInternal = exports.LoadFileInternal || (exports.LoadFileInternal = {}));
 function isHttpProtocol(url) {
     return /^(http|https)\:\/\//.test(url);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akashic/headless-driver",
-  "version": "2.6.2",
+  "version": "2.7.0",
   "description": "A library to execute contents using Akashic Engine headlessly",
   "main": "lib/index.js",
   "author": "DWANGO Co., Ltd.",
@@ -55,7 +55,7 @@
     "jest": "^29.1.2",
     "npm-run-all": "^4.1.5",
     "pixelmatch": "^5.3.0",
-    "pngjs": "^6.0.0",
+    "pngjs": "^7.0.0",
     "prettier": "^2.7.1",
     "remark-cli": "^11.0.0",
     "rimraf": "^4.0.0",