@akashic/headless-driver 1.11.36 → 2.0.0

package/lib/runner/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./v1";
+export * from "./v2";
+export * from "./v3";
+export * from "./Platform";
+export * from "./Runner";
+export * from "./RunnerManager";
+export * from "./types";

package/lib/runner/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;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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("./v1"), exports);
+__exportStar(require("./v2"), exports);
+__exportStar(require("./v3"), exports);
+__exportStar(require("./Platform"), exports);
+__exportStar(require("./Runner"), exports);
+__exportStar(require("./RunnerManager"), exports);
+__exportStar(require("./types"), exports);

package/lib/runner/types.d.ts

@@ -0,0 +1,15 @@
+export declare type RunnerExecutionMode = "active" | "passive";
+export declare type RunnerRenderingMode = "none" | "canvas";
+export declare type RunnerAdvanceConditionFunc = () => boolean;
+export interface RunnerPointEvent {
+    type: "down" | "move" | "up";
+    identifier: number;
+    offset: {
+        x: number;
+        y: number;
+    };
+}
+export interface RunnerPlayer {
+    id: string;
+    name: string;
+}

package/lib/runner/types.js

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

package/lib/runner/v1/RunnerV1.d.ts

@@ -0,0 +1,26 @@
+import { akashicEngine as g, gameDriver as gdr } from "aev1";
+import type { RunnerStartParameters } from "../Runner";
+import { Runner } from "../Runner";
+import type { RunnerPointEvent } from "../types";
+import { PlatformV1 } from "./platform/PlatformV1";
+export declare type RunnerV1Game = g.Game;
+export declare class RunnerV1 extends Runner {
+    readonly engineVersion: string;
+    readonly g: typeof g;
+    platform: PlatformV1 | null;
+    private driver;
+    private fps;
+    private running;
+    start(params?: RunnerStartParameters): Promise<RunnerV1Game | null>;
+    stop(): void;
+    pause(): void;
+    resume(): void;
+    step(): void;
+    protected _stepMinimal(): void;
+    advance(ms: number): Promise<void>;
+    changeGameDriverState(param: gdr.GameDriverInitializeParameterObject): Promise<void>;
+    firePointEvent(event: RunnerPointEvent): void;
+    getPrimarySurface(): never;
+    private initGameDriver;
+    private onSendedToExternal;
+}

package/lib/runner/v1/RunnerV1.js

@@ -0,0 +1,230 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunnerV1 = void 0;
+const aev1_1 = require("aev1");
+const Runner_1 = require("../Runner");
+const PlatformV1_1 = require("./platform/PlatformV1");
+class RunnerV1 extends Runner_1.Runner {
+    constructor() {
+        super(...arguments);
+        this.engineVersion = "1";
+        this.g = aev1_1.akashicEngine;
+        this.platform = null;
+        this.driver = null;
+        this.fps = null;
+        this.running = false;
+    }
+    start(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let game = null;
+            const paused = !!(params === null || params === void 0 ? void 0 : params.paused);
+            try {
+                game = yield this.initGameDriver();
+                if (!paused) {
+                    this.resume();
+                }
+            }
+            catch (e) {
+                this.onError(e);
+            }
+            return game;
+        });
+    }
+    stop() {
+        if (this.driver) {
+            this.driver.stopGame();
+            this.driver = null;
+        }
+        this.running = false;
+    }
+    pause() {
+        if (this.platform == null) {
+            this.errorTrigger.fire(new Error("Cannot call Runner#pause() before initialized"));
+            return;
+        }
+        this.platform.pauseLoopers();
+        this.running = false;
+    }
+    resume() {
+        if (this.platform == null) {
+            this.errorTrigger.fire(new Error("Cannot call Runner#resume() before initialized"));
+            return;
+        }
+        this.platform.resumeLoopers();
+        this.running = true;
+    }
+    step() {
+        if (this.fps == null || this.platform == null) {
+            this.errorTrigger.fire(new Error("Cannot call Runner#step() before initialized"));
+            return;
+        }
+        if (this.running) {
+            this.errorTrigger.fire(new Error("Cannot call Runner#step() in running"));
+            return;
+        }
+        this.platform.advanceLoopers(Math.ceil(1000 / this.fps));
+    }
+    _stepMinimal() {
+        if (this.fps == null || this.platform == null) {
+            this.errorTrigger.fire(new Error("RunnerV1#_stepHalf(): Cannot call Runner#step() before initialized"));
+            return;
+        }
+        if (this.running) {
+            this.errorTrigger.fire(new Error("RunnerV1#_stepHalf(): Cannot call Runner#step() in running"));
+            return;
+        }
+        // NOTE: 現状 PDI の API 仕様により this.step() では厳密なフレーム更新ができない。そこで、一フレームの 1/2 の時間で進行することでフレームが飛んでしまうことを防止する。
+        this.platform.advanceLoopers(1000 / this.fps / 2);
+    }
+    advance(ms) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.fps == null || this.platform == null || this.driver == null) {
+                this.errorTrigger.fire(new Error("Cannot call Runner#advance() before initialized"));
+                return;
+            }
+            if (this.running) {
+                this.errorTrigger.fire(new Error("Cannot call Runner#advance() in running"));
+                return;
+            }
+            const { loopMode, skipThreshold } = this.driver.getLoopConfiguration();
+            // NOTE: skip の通知タイミングを一度に制限するため skipThreshold を一時的に変更する。
+            yield this.changeGameDriverState({
+                loopConfiguration: {
+                    loopMode,
+                    skipThreshold: Math.ceil(ms / this.fps) + 1
+                }
+            });
+            const delta = Math.ceil(1000 / this.fps);
+            let progress = 0;
+            while (progress <= ms) {
+                // NOTE: game-driver の内部実装により Looper 経由で一度に進める時間に制限がある。
+                // そのため一度に進める時間を fps に応じて分割する。
+                this.platform.advanceLoopers(delta);
+                progress += delta;
+            }
+            yield this.changeGameDriverState({
+                loopConfiguration: {
+                    loopMode,
+                    skipThreshold
+                }
+            });
+        });
+    }
+    changeGameDriverState(param) {
+        return new Promise((resolve, reject) => {
+            if (!this.driver) {
+                reject(new Error("Game is not started"));
+                return;
+            }
+            this.driver.changeState(param, (err) => (err ? reject(err) : resolve()));
+        });
+    }
+    firePointEvent(event) {
+        if (this.platform == null) {
+            this.errorTrigger.fire(new Error("Cannot call Runner#firePointEvent() before initialized"));
+            return;
+        }
+        let type;
+        if (event.type === "down") {
+            type = 0 /* Down */;
+        }
+        else if (event.type === "move") {
+            type = 1 /* Move */;
+        }
+        else if (event.type === "up") {
+            type = 2 /* Up */;
+        }
+        else {
+            this.errorTrigger.fire(new Error(`RunnerV1#firePointEvent(): unknown event type: ${event.type}`));
+            return;
+        }
+        this.platform.firePointEvent({
+            type,
+            identifier: event.identifier,
+            offset: event.offset
+        });
+    }
+    getPrimarySurface() {
+        throw new Error("RunnerV1#getPrimarySurface(): Not supported");
+    }
+    initGameDriver() {
+        return new Promise((resolve, reject) => {
+            if (this.driver) {
+                this.driver.destroy();
+                this.driver = null;
+            }
+            const player = {
+                id: this.player ? this.player.id : undefined,
+                name: this.player ? this.player.name : undefined
+            };
+            const executionMode = this.executionMode === "active" ? aev1_1.gameDriver.ExecutionMode.Active : aev1_1.gameDriver.ExecutionMode.Passive;
+            this.platform = new PlatformV1_1.PlatformV1({
+                configurationBaseUrl: this.configurationBaseUrl,
+                assetBaseUrl: this.assetBaseUrl,
+                amflow: this.amflow,
+                trusted: this.trusted,
+                renderingMode: this.renderingMode,
+                sendToExternalHandler: (data) => this.onSendedToExternal(data),
+                errorHandler: (e) => this.onError(e),
+                loadFileHandler: (url, callback) => this.loadFileHandler(url, callback)
+            });
+            this.pause();
+            const driver = new aev1_1.gameDriver.GameDriver({
+                platform: this.platform,
+                player,
+                errorHandler: (e) => this.onError(e)
+            });
+            this.driver = driver;
+            let result = null;
+            // TODO: パラメータを外部から変更可能にする
+            driver.initialize({
+                configurationUrl: this.configurationUrl,
+                configurationBase: this.configurationBaseUrl,
+                assetBase: this.assetBaseUrl,
+                driverConfiguration: {
+                    playId: this.playId,
+                    playToken: this.playToken,
+                    executionMode
+                },
+                loopConfiguration: {
+                    loopMode: aev1_1.gameDriver.LoopMode.Realtime
+                },
+                gameArgs: this.gameArgs
+            }, (e) => {
+                if (e) {
+                    reject(e);
+                    return;
+                }
+                if (!result) {
+                    // GameDriver の内部実装上ここに来ることはないはずだが念のため確認
+                    return reject(new Error("Game is null."));
+                }
+                driver.startGame();
+                resolve(result);
+            });
+            driver.gameCreatedTrigger.handle((game) => {
+                if (this.externalValue) {
+                    Object.keys(this.externalValue).forEach((key) => {
+                        game.external[key] = this.externalValue[key];
+                    });
+                }
+                this.fps = game.fps;
+                result = game;
+                return true;
+            });
+        });
+    }
+    onSendedToExternal(data) {
+        this.sendToExternalTrigger.fire(data);
+    }
+}
+exports.RunnerV1 = RunnerV1;

package/lib/runner/v1/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./RunnerV1";
+export * from "./platform/PlatformV1";
+export { akashicEngine as RunnerV1_g, gameDriver as RunnerV1_gdr, pdi as RunnerV1_pdi } from "aev1";

package/lib/runner/v1/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;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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.RunnerV1_pdi = exports.RunnerV1_gdr = exports.RunnerV1_g = void 0;
+__exportStar(require("./RunnerV1"), exports);
+__exportStar(require("./platform/PlatformV1"), exports);
+var aev1_1 = require("aev1");
+Object.defineProperty(exports, "RunnerV1_g", { enumerable: true, get: function () { return aev1_1.akashicEngine; } });
+Object.defineProperty(exports, "RunnerV1_gdr", { enumerable: true, get: function () { return aev1_1.gameDriver; } });
+Object.defineProperty(exports, "RunnerV1_pdi", { enumerable: true, get: function () { return aev1_1.pdi; } });

package/lib/runner/v1/platform/NullAudioPlayer.d.ts

@@ -0,0 +1,3 @@
+import { akashicEngine as g } from "aev1";
+export declare class NullAudioPlayer extends g.AudioPlayer {
+}

package/lib/runner/v1/platform/NullAudioPlayer.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullAudioPlayer = void 0;
+const aev1_1 = require("aev1");
+class NullAudioPlayer extends aev1_1.akashicEngine.AudioPlayer {
+}
+exports.NullAudioPlayer = NullAudioPlayer;

package/lib/runner/v1/platform/NullGlyphFactory.d.ts

@@ -0,0 +1,6 @@
+import { akashicEngine as g } from "aev1";
+export declare class NullGlyphFactory extends g.GlyphFactory {
+    private dummySurface;
+    create(code: number): g.Glyph;
+    measureMinimumFontSize(): number;
+}

package/lib/runner/v1/platform/NullGlyphFactory.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullGlyphFactory = void 0;
+const aev1_1 = require("aev1");
+const NullSurface_1 = require("./NullSurface");
+class NullGlyphFactory extends aev1_1.akashicEngine.GlyphFactory {
+    constructor() {
+        super(...arguments);
+        this.dummySurface = new NullSurface_1.NullSurface(0, 0);
+    }
+    create(code) {
+        return new aev1_1.akashicEngine.Glyph(code, 0, 0, 0, 0, 0, 0, this.fontSize, this.dummySurface, true);
+    }
+    measureMinimumFontSize() {
+        return 1;
+    }
+}
+exports.NullGlyphFactory = NullGlyphFactory;

package/lib/runner/v1/platform/NullRenderer.d.ts

@@ -0,0 +1,16 @@
+import { akashicEngine as g } from "aev1";
+export declare class NullRenderer extends g.Renderer {
+    clear(): void;
+    drawImage(_surface: g.Surface, _offsetX: number, _offsetY: number, _width: number, _height: number, _destOffsetX: number, _destOffsetY: number): void;
+    drawSprites(_surface: g.Surface, _offsetX: number[], _offsetY: number[], _width: number[], _height: number[], _canvasOffsetX: number[], _canvasOffsetY: number[], _count: number): void;
+    drawSystemText(_text: string, _x: number, _y: number, _maxWidth: number, _fontSize: number, _textAlign: g.TextAlign, _textBaseline: g.TextBaseline, _textColor: string, _fontFamily: g.FontFamily, _strokeWidth: number, _strokeColor: string, _strokeOnly: boolean): void;
+    translate(_x: number, _y: number): void;
+    transform(_matrix: number[]): void;
+    opacity(_opacity: number): void;
+    save(): void;
+    restore(): void;
+    fillRect(_x: number, _y: number, _width: number, _height: number, _cssColor: string): void;
+    setCompositeOperation(_operation: g.CompositeOperation): void;
+    setTransform(_matrix: number[]): void;
+    setOpacity(_opacity: number): void;
+}

package/lib/runner/v1/platform/NullRenderer.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullRenderer = void 0;
+const aev1_1 = require("aev1");
+class NullRenderer extends aev1_1.akashicEngine.Renderer {
+    clear() {
+        //
+    }
+    drawImage(_surface, _offsetX, _offsetY, _width, _height, _destOffsetX, _destOffsetY) {
+        //
+    }
+    drawSprites(_surface, _offsetX, _offsetY, _width, _height, _canvasOffsetX, _canvasOffsetY, _count) {
+        //
+    }
+    drawSystemText(_text, _x, _y, _maxWidth, _fontSize, _textAlign, _textBaseline, _textColor, _fontFamily, _strokeWidth, _strokeColor, _strokeOnly) {
+        //
+    }
+    translate(_x, _y) {
+        //
+    }
+    transform(_matrix) {
+        //
+    }
+    opacity(_opacity) {
+        //
+    }
+    save() {
+        //
+    }
+    restore() {
+        //
+    }
+    fillRect(_x, _y, _width, _height, _cssColor) {
+        //
+    }
+    setCompositeOperation(_operation) {
+        //
+    }
+    setTransform(_matrix) {
+        //
+    }
+    setOpacity(_opacity) {
+        //
+    }
+}
+exports.NullRenderer = NullRenderer;

package/lib/runner/v1/platform/NullSurface.d.ts

@@ -0,0 +1,7 @@
+import { akashicEngine as g } from "aev1";
+export declare class NullSurface extends g.Surface {
+    private _renderer;
+    constructor(width: number, height: number, drawable?: any, isDynamic?: boolean);
+    renderer(): g.Renderer;
+    isPlaying(): boolean;
+}

package/lib/runner/v1/platform/NullSurface.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullSurface = void 0;
+const aev1_1 = require("aev1");
+const NullRenderer_1 = require("./NullRenderer");
+class NullSurface extends aev1_1.akashicEngine.Surface {
+    constructor(width, height, drawable, isDynamic) {
+        super(width, height, drawable, isDynamic);
+        this._renderer = new NullRenderer_1.NullRenderer();
+    }
+    renderer() {
+        return this._renderer;
+    }
+    isPlaying() {
+        return false;
+    }
+}
+exports.NullSurface = NullSurface;

package/lib/runner/v1/platform/NullVideoPlayer.d.ts

@@ -0,0 +1,4 @@
+import { akashicEngine as g } from "aev1";
+export declare class NullVideoplayerAsset extends g.VideoPlayer {
+    isDummy(): boolean;
+}

package/lib/runner/v1/platform/NullVideoPlayer.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullVideoplayerAsset = void 0;
+const aev1_1 = require("aev1");
+class NullVideoplayerAsset extends aev1_1.akashicEngine.VideoPlayer {
+    isDummy() {
+        return true;
+    }
+}
+exports.NullVideoplayerAsset = NullVideoplayerAsset;

package/lib/runner/v1/platform/PlatformV1.d.ts

@@ -0,0 +1,22 @@
+import type { akashicEngine as g, pdi } from "aev1";
+import { Looper } from "../../../Looper";
+import type { PlatformParameters } from "../../Platform";
+import { Platform } from "../../Platform";
+export declare class PlatformV1 extends Platform implements pdi.Platform {
+    private resFac;
+    private rendererReq;
+    private primarySurface;
+    private eventHandler;
+    private loopers;
+    private isLooperPaused;
+    constructor(param: PlatformParameters);
+    getResourceFactory(): g.ResourceFactory;
+    setRendererRequirement(requirement: pdi.RendererRequirement): void;
+    setPlatformEventHandler(handler: pdi.PlatformEventHandler): void;
+    getPrimarySurface(): g.Surface;
+    createLooper(fun: (deltaTime: number) => number): Looper;
+    advanceLoopers(ms: number): void;
+    pauseLoopers(): void;
+    resumeLoopers(): void;
+    firePointEvent(event: pdi.PointEvent): void;
+}

package/lib/runner/v1/platform/PlatformV1.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlatformV1 = void 0;
+const Looper_1 = require("../../../Looper");
+const Platform_1 = require("../../Platform");
+const NullSurface_1 = require("./NullSurface");
+const ResourceFactory_1 = require("./ResourceFactory");
+class PlatformV1 extends Platform_1.Platform {
+    constructor(param) {
+        super(param);
+        this.rendererReq = null;
+        this.primarySurface = null;
+        this.eventHandler = null;
+        this.loopers = [];
+        this.isLooperPaused = false;
+        this.resFac = new ResourceFactory_1.ResourceFactory({
+            errorHandler: (e) => this.errorHandler(e),
+            loadFileHandler: param.loadFileHandler
+        });
+    }
+    getResourceFactory() {
+        return this.resFac;
+    }
+    setRendererRequirement(requirement) {
+        this.rendererReq = requirement;
+        this.primarySurface = new NullSurface_1.NullSurface(this.rendererReq.primarySurfaceWidth, this.rendererReq.primarySurfaceHeight, null);
+    }
+    setPlatformEventHandler(handler) {
+        this.eventHandler = handler;
+    }
+    getPrimarySurface() {
+        if (this.primarySurface == null) {
+            throw new Error("PlatformV1#getPrimarySurface(): Primary surface has not been initialized yet");
+        }
+        return this.primarySurface;
+    }
+    createLooper(fun) {
+        const looper = new Looper_1.Looper(fun, (e) => this.errorHandler(e));
+        if (this.isLooperPaused) {
+            looper.debugStop();
+        }
+        this.loopers.push(looper);
+        return looper;
+    }
+    advanceLoopers(ms) {
+        for (let i = 0; i < this.loopers.length; i++) {
+            this.loopers[i].debugStep(ms);
+        }
+    }
+    pauseLoopers() {
+        this.isLooperPaused = true;
+        for (let i = 0; i < this.loopers.length; i++) {
+            this.loopers[i].debugStop();
+        }
+    }
+    resumeLoopers() {
+        this.isLooperPaused = false;
+        for (let i = 0; i < this.loopers.length; i++) {
+            this.loopers[i].debugStart();
+        }
+    }
+    firePointEvent(event) {
+        var _a;
+        (_a = this.eventHandler) === null || _a === void 0 ? void 0 : _a.onPointEvent(event);
+    }
+}
+exports.PlatformV1 = PlatformV1;

package/lib/runner/v1/platform/ResourceFactory.d.ts

@@ -0,0 +1,18 @@
+import { akashicEngine as g } from "aev1";
+export interface ResourceFactoryParameters {
+    loadFileHandler: (url: string, callback: (err: Error | null, data?: string) => void) => void;
+    errorHandler: (err: any) => void;
+}
+export declare class ResourceFactory extends g.ResourceFactory {
+    private loadFileHandler;
+    private errorHandler;
+    constructor({ loadFileHandler, errorHandler }: ResourceFactoryParameters);
+    createImageAsset(id: string, assetPath: string, width: number, height: number): g.ImageAsset;
+    createVideoAsset(id: string, assetPath: string, width: number, height: number, system: g.VideoSystem, loop: boolean, useRealSize: boolean): g.VideoAsset;
+    createAudioAsset(id: string, assetPath: string, duration: number, system: g.AudioSystem, loop: boolean, hint: g.AudioAssetHint): g.AudioAsset;
+    createAudioPlayer(system: g.AudioSystem): g.AudioPlayer;
+    createTextAsset(id: string, assetPath: string): g.TextAsset;
+    createScriptAsset(id: string, assetPath: string): g.ScriptAsset;
+    createSurface(width: number, height: number): g.Surface;
+    createGlyphFactory(fontFamily: g.FontFamily | string | (g.FontFamily | string)[], fontSize: number, baselineHeight?: number, fontColor?: string, strokeWidth?: number, strokeColor?: string, strokeOnly?: boolean, fontWeight?: g.FontWeight): g.GlyphFactory;
+}

package/lib/runner/v1/platform/ResourceFactory.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceFactory = void 0;
+const aev1_1 = require("aev1");
+const NodeScriptAsset_1 = require("./assets/NodeScriptAsset");
+const NodeTextAsset_1 = require("./assets/NodeTextAsset");
+const NullAudioAsset_1 = require("./assets/NullAudioAsset");
+const NullImageAsset_1 = require("./assets/NullImageAsset");
+const NullVideoAsset_1 = require("./assets/NullVideoAsset");
+const NullAudioPlayer_1 = require("./NullAudioPlayer");
+const NullGlyphFactory_1 = require("./NullGlyphFactory");
+const NullSurface_1 = require("./NullSurface");
+class ResourceFactory extends aev1_1.akashicEngine.ResourceFactory {
+    constructor({ loadFileHandler, errorHandler }) {
+        super();
+        this.loadFileHandler = loadFileHandler;
+        this.errorHandler = errorHandler;
+    }
+    createImageAsset(id, assetPath, width, height) {
+        return new NullImageAsset_1.NullImageAsset(id, assetPath, width, height);
+    }
+    createVideoAsset(id, assetPath, width, height, system, loop, useRealSize) {
+        return new NullVideoAsset_1.NullVideoAsset(id, assetPath, width, height, system, loop, useRealSize);
+    }
+    createAudioAsset(id, assetPath, duration, system, loop, hint) {
+        return new NullAudioAsset_1.NullAudioAsset(id, assetPath, duration, system, loop, hint);
+    }
+    createAudioPlayer(system) {
+        return new NullAudioPlayer_1.NullAudioPlayer(system);
+    }
+    createTextAsset(id, assetPath) {
+        return new NodeTextAsset_1.NodeTextAsset({
+            id,
+            path: assetPath,
+            loadFileHandler: this.loadFileHandler
+        });
+    }
+    createScriptAsset(id, assetPath) {
+        return new NodeScriptAsset_1.NodeScriptAsset({
+            id,
+            path: assetPath,
+            errorHandler: this.errorHandler,
+            loadFileHandler: this.loadFileHandler
+        });
+    }
+    createSurface(width, height) {
+        return new NullSurface_1.NullSurface(width, height);
+    }
+    createGlyphFactory(fontFamily, fontSize, baselineHeight, fontColor, strokeWidth, strokeColor, strokeOnly, fontWeight) {
+        return new NullGlyphFactory_1.NullGlyphFactory(fontFamily, fontSize, baselineHeight, fontColor, strokeWidth, strokeColor, strokeOnly, fontWeight);
+    }
+}
+exports.ResourceFactory = ResourceFactory;

package/lib/runner/v1/platform/assets/NodeScriptAsset.d.ts

@@ -0,0 +1,16 @@
+import { akashicEngine as g } from "aev1";
+export interface NodeScriptAssetParameters {
+    id: string;
+    path: string;
+    errorHandler: (err: any) => void;
+    loadFileHandler: (url: string, callback: (err: Error | null, data?: string) => void) => void;
+}
+export declare class NodeScriptAsset extends g.ScriptAsset {
+    static PRE_SCRIPT: string;
+    static POST_SCRIPT: string;
+    private errorHandler;
+    private loadFileHandler;
+    constructor(param: NodeScriptAssetParameters);
+    _load(loader: g.AssetLoadHandler): void;
+    execute(execEnv: g.ScriptAssetExecuteEnvironment): any;
+}