@cyclonium/core 0.0.100

package/lib/framework/coroutine.js

@@ -0,0 +1,278 @@
+var CoroutineInstructionType;
+(function (CoroutineInstructionType) {
+    CoroutineInstructionType[CoroutineInstructionType["nextFrame"] = 0] = "nextFrame";
+    CoroutineInstructionType[CoroutineInstructionType["waitFor"] = 1] = "waitFor";
+    CoroutineInstructionType[CoroutineInstructionType["waitUntil"] = 2] = "waitUntil";
+    CoroutineInstructionType[CoroutineInstructionType["waitWhile"] = 3] = "waitWhile";
+})(CoroutineInstructionType || (CoroutineInstructionType = {}));
+const NEXT_FRAME_INSTRUCTION = {
+    type: CoroutineInstructionType.nextFrame,
+};
+/**
+ * Resume the coroutine on the next coroutine update.
+ * @returns An opaque instruction to yield from a coroutine.
+ */
+export function nextFrame() {
+    return NEXT_FRAME_INSTRUCTION;
+}
+/**
+ * Resume the coroutine after at least the given duration.
+ * @param seconds - Duration to wait, in seconds. Must be a non-negative finite number.
+ * @returns An opaque instruction to yield from a coroutine.
+ */
+export function waitFor(seconds) {
+    if (!Number.isFinite(seconds) || seconds < 0) {
+        throw new Error('seconds must be a non-negative finite number.');
+    }
+    return {
+        type: CoroutineInstructionType.waitFor,
+        seconds,
+    };
+}
+/**
+ * Resume the coroutine when the predicate becomes true.
+ * @param predicate - Function evaluated each coroutine update with the current frame.
+ * @returns An opaque instruction to yield from a coroutine.
+ */
+export function waitUntil(predicate) {
+    return {
+        type: CoroutineInstructionType.waitUntil,
+        predicate,
+    };
+}
+/**
+ * Resume the coroutine when the predicate becomes false.
+ * @param predicate - Function evaluated each coroutine update with the current frame.
+ * @returns An opaque instruction to yield from a coroutine.
+ */
+export function waitWhile(predicate) {
+    return {
+        type: CoroutineInstructionType.waitWhile,
+        predicate,
+    };
+}
+export class CoroutineRunner {
+    start(coroutine, opts) {
+        const record = new CoroutineRecord(this, coroutine, opts);
+        this._records.push(record);
+        record.start();
+        this._pruneIfNotDeferred();
+        return record;
+    }
+    update(deltaTime) {
+        this._frame++;
+        this._deltaTime = deltaTime;
+        this._beginPruneDeferral();
+        try {
+            const count = this._records.length;
+            for (let i = 0; i < count; i++) {
+                this._records[i].update();
+            }
+        }
+        finally {
+            this._endPruneDeferral();
+        }
+    }
+    stop(handle) {
+        stopCoroutine(handle);
+        this._pruneIfNotDeferred();
+    }
+    stopAll() {
+        this._beginPruneDeferral();
+        try {
+            const count = this._records.length;
+            for (let i = 0; i < count; i++) {
+                this._records[i].stop();
+            }
+        }
+        finally {
+            this._endPruneDeferral();
+        }
+    }
+    get frame() {
+        return this._frame;
+    }
+    get deltaTime() {
+        return this._deltaTime;
+    }
+    get empty() {
+        return this._records.length === 0;
+    }
+    _records = [];
+    _frame = 0;
+    _deltaTime = 0;
+    _pruneDeferralDepth = 0;
+    _beginPruneDeferral() {
+        this._pruneDeferralDepth++;
+    }
+    _endPruneDeferral() {
+        this._pruneDeferralDepth--;
+        if (this._pruneDeferralDepth === 0) {
+            this._prune();
+        }
+    }
+    _pruneIfNotDeferred() {
+        if (this._pruneDeferralDepth === 0) {
+            this._prune();
+        }
+    }
+    _prune() {
+        this._records = this._records.filter((record) => !record.done);
+    }
+}
+export function stopCoroutine(coroutine) {
+    if (coroutine instanceof CoroutineRecord) {
+        coroutine.stop();
+        return;
+    }
+    throw new Error('Invalid coroutine handle.');
+}
+class CoroutineRecord {
+    constructor(runner, coroutine, opts) {
+        this._runner = runner;
+        this._coroutine = coroutine;
+        this._signal = opts?.signal;
+    }
+    get running() {
+        return !this._done && !this._stopping;
+    }
+    get done() {
+        return this._done;
+    }
+    start() {
+        if (this._signal?.aborted) {
+            this.stop();
+            return;
+        }
+        this._addAbortListener();
+        this._advance();
+    }
+    update() {
+        if (!this.running || this._yieldedAtFrame >= this._runner.frame) {
+            return;
+        }
+        this._elapsedTime += this._runner.deltaTime;
+        this._frame.deltaTime = this._runner.deltaTime;
+        this._frame.elapsedTime = this._elapsedTime;
+        this._frame.frame = this._runner.frame;
+        if (this._canResume(this._frame)) {
+            this._advance(this._frame);
+        }
+    }
+    stop() {
+        if (this._done) {
+            return;
+        }
+        this._done = true;
+        this._removeAbortListener();
+        if (this._executing) {
+            return;
+        }
+        this._stopping = true;
+        try {
+            this._coroutine.return?.(undefined);
+        }
+        finally {
+            this._stopping = false;
+        }
+    }
+    _runner;
+    _coroutine;
+    _signal;
+    _instruction = NEXT_FRAME_INSTRUCTION;
+    _frame = {
+        deltaTime: 0,
+        elapsedTime: 0,
+        frame: 0,
+    };
+    _yieldedAtFrame = 0;
+    _remainingSeconds = 0;
+    _elapsedTime = 0;
+    _done = false;
+    _executing = false;
+    _stopping = false;
+    _advance(frame) {
+        let result;
+        this._executing = true;
+        try {
+            result = frame === undefined ? this._coroutine.next() : this._coroutine.next(frame);
+        }
+        catch (error) {
+            this._done = true;
+            this._removeAbortListener();
+            throw error;
+        }
+        finally {
+            this._executing = false;
+        }
+        if (this._done) {
+            return;
+        }
+        if (result.done === true) {
+            this._done = true;
+            this._removeAbortListener();
+            return;
+        }
+        this._setInstruction(result.value);
+    }
+    _setInstruction(instruction) {
+        if (instruction === null || instruction === undefined) {
+            this._instruction = NEXT_FRAME_INSTRUCTION;
+        }
+        else {
+            switch (instruction.type) {
+                case CoroutineInstructionType.nextFrame:
+                    this._instruction = instruction;
+                    break;
+                case CoroutineInstructionType.waitFor:
+                    this._instruction = instruction;
+                    break;
+                case CoroutineInstructionType.waitUntil:
+                case CoroutineInstructionType.waitWhile:
+                    this._instruction = instruction;
+                    break;
+                default:
+                    throw new Error('Invalid coroutine instruction.');
+            }
+        }
+        this._yieldedAtFrame = this._runner.frame;
+        switch (this._instruction.type) {
+            case CoroutineInstructionType.waitFor:
+                this._remainingSeconds = this._instruction.seconds;
+                break;
+            default:
+                break;
+        }
+    }
+    _canResume(frame) {
+        switch (this._instruction.type) {
+            case CoroutineInstructionType.nextFrame:
+                return true;
+            case CoroutineInstructionType.waitFor:
+                this._remainingSeconds -= frame.deltaTime;
+                return this._remainingSeconds <= 0;
+            case CoroutineInstructionType.waitUntil:
+                return this._instruction.predicate(frame);
+            case CoroutineInstructionType.waitWhile:
+                return !this._instruction.predicate(frame);
+        }
+    }
+    _addAbortListener() {
+        if (!this._signal || this._onAbort) {
+            return;
+        }
+        this._onAbort = () => {
+            this.stop();
+        };
+        this._signal.addEventListener('abort', this._onAbort);
+    }
+    _removeAbortListener() {
+        if (!this._signal || !this._onAbort) {
+            return;
+        }
+        this._signal.removeEventListener('abort', this._onAbort);
+        this._onAbort = undefined;
+    }
+    _onAbort = undefined;
+}
+//# sourceMappingURL=coroutine.js.map

package/lib/framework/execution-order.d.ts

@@ -0,0 +1,12 @@
+import { CycloComponent } from './component.ts';
+export declare enum PredefinedExecutionOrder {
+    earlier = -100,
+    physics = -50,
+    normal = 0,
+    notSoLate = 10,
+    later = 50,
+    rendering = 200
+}
+export declare function setExecutionOrder(componentClass: new (...args: never[]) => CycloComponent, value: number): void;
+export declare function getExecutionOrder(componentClass: new (...args: never[]) => CycloComponent): number;
+//# sourceMappingURL=execution-order.d.ts.map

package/lib/framework/execution-order.js

@@ -0,0 +1,17 @@
+import { CycloComponent } from "./component.js";
+export var PredefinedExecutionOrder;
+(function (PredefinedExecutionOrder) {
+    PredefinedExecutionOrder[PredefinedExecutionOrder["earlier"] = -100] = "earlier";
+    PredefinedExecutionOrder[PredefinedExecutionOrder["physics"] = -50] = "physics";
+    PredefinedExecutionOrder[PredefinedExecutionOrder["normal"] = 0] = "normal";
+    PredefinedExecutionOrder[PredefinedExecutionOrder["notSoLate"] = 10] = "notSoLate";
+    PredefinedExecutionOrder[PredefinedExecutionOrder["later"] = 50] = "later";
+    PredefinedExecutionOrder[PredefinedExecutionOrder["rendering"] = 200] = "rendering";
+})(PredefinedExecutionOrder || (PredefinedExecutionOrder = {}));
+export function setExecutionOrder(componentClass, value) {
+    componentClass._executionOrder = value;
+}
+export function getExecutionOrder(componentClass) {
+    return componentClass._executionOrder || PredefinedExecutionOrder.normal;
+}
+//# sourceMappingURL=execution-order.js.map

package/lib/framework/tasking.d.ts

@@ -0,0 +1,17 @@
+export declare const TaskPriority: {
+    predefined: Readonly<{
+        componentsLateUpdate: 0;
+    }>;
+    before(priority: number): number;
+    after(priority: number): number;
+    between(a: number, b: number): number;
+};
+interface Task<TThis = any> {
+    fn: (this: TThis, deltaTime: number) => void;
+    thisArg: TThis;
+    priority: number;
+}
+export declare function addFrameTask<TThis>(task: Task<TThis>): void;
+export declare function removeFrameTask<TThis>(task: Task<TThis>): void;
+export {};
+//# sourceMappingURL=tasking.d.ts.map

package/lib/framework/tasking.js

@@ -0,0 +1,82 @@
+import * as cc from 'cc';
+export const TaskPriority = {
+    predefined: Object.freeze({
+        componentsLateUpdate: 0,
+    }),
+    before(priority) {
+        return priority - 1;
+    },
+    after(priority) {
+        return priority + 1;
+    },
+    between(a, b) {
+        return (a + b) / 2;
+    },
+};
+class TaskCluster {
+    add(task) {
+        const taskIndex = this._find(task);
+        if (taskIndex >= 0) {
+            return false;
+        }
+        this._tasks.push({
+            ...task,
+        });
+        this._tasks.sort((a, b) => b.priority - a.priority);
+        return true;
+    }
+    remove(task) {
+        const taskIndex = this._find(task);
+        if (taskIndex < 0) {
+            return false;
+        }
+        this._tasks.splice(taskIndex, 1);
+        return true;
+    }
+    execute(deltaTime) {
+        for (const task of this._tasks) {
+            task.fn.call(task.thisArg, deltaTime);
+        }
+    }
+    _tasks = [];
+    _find(task) {
+        return this._tasks.findIndex((t) => t.fn === task.fn && t.thisArg === task.thisArg);
+    }
+}
+class CycloTaskScheduler extends cc.System {
+    add(task) {
+        const cluster = this._getCluster(task.priority);
+        cluster.add(task);
+    }
+    remove(task) {
+        for (const cluster of [this._clusterBeforeComponentsLateUpdate, this._clusterAfterComponentsLateUpdate]) {
+            const removed = cluster.remove(task);
+            if (removed) {
+                return;
+            }
+        }
+    }
+    update(deltaTime) {
+        this._clusterBeforeComponentsLateUpdate.execute(deltaTime);
+    }
+    postUpdate(deltaTime) {
+        this._clusterAfterComponentsLateUpdate.execute(deltaTime);
+    }
+    _clusterBeforeComponentsLateUpdate = new TaskCluster();
+    _clusterAfterComponentsLateUpdate = new TaskCluster();
+    _getCluster(priority) {
+        if (priority <= TaskPriority.predefined.componentsLateUpdate) {
+            return this._clusterBeforeComponentsLateUpdate;
+        }
+        return this._clusterAfterComponentsLateUpdate;
+    }
+}
+const taskScheduler = new CycloTaskScheduler();
+cc.director.registerSystem('CycloTasks', taskScheduler, cc.System.Priority.MEDIUM);
+export function addFrameTask(task) {
+    taskScheduler.add(task);
+}
+export function removeFrameTask(task) {
+    taskScheduler.remove(task);
+}
+//# sourceMappingURL=tasking.js.map

package/lib/math/bounds-2d.d.ts

@@ -0,0 +1,2 @@
+export * from '@cyclonium/math/bounds-2d';
+//# sourceMappingURL=bounds-2d.d.ts.map

package/lib/math/bounds-2d.js

@@ -0,0 +1,13 @@
+import { Bounds2D } from '@cyclonium/math/bounds-2d';
+import { applyLegacyDecorators, serializable, editable } from "../export/legacy-decorator.js";
+import { cycloBuiltinClass } from "../decorator/legacy/legacy-decorator.js";
+export * from '@cyclonium/math/bounds-2d';
+applyLegacyDecorators(Bounds2D, {
+    classDecorators: [cycloBuiltinClass('Bounds2D')],
+    propertyDecorators: {
+        // @ts-expect-error
+        _min: [serializable, editable],
+        _max: [serializable, editable],
+    },
+});
+//# sourceMappingURL=bounds-2d.js.map

package/lib/math/geometry.d.ts

@@ -0,0 +1,4 @@
+import { Vec2 } from './vec2.ts';
+import { Ray2D } from './ray.ts';
+export declare function raycastLineSegment2D(ray: Ray2D, p0: Vec2, p1: Vec2): number | undefined;
+//# sourceMappingURL=geometry.d.ts.map

package/lib/math/geometry.js

@@ -0,0 +1,19 @@
+import { Vec2 } from "./vec2.js";
+import { Ray2D } from "./ray.js";
+export function raycastLineSegment2D(ray, p0, p1) {
+    const v1 = ray.origin.sub(p0);
+    const v2 = p1.sub(p0);
+    const v3 = new Vec2(-ray.direction.y, ray.direction.x);
+    const dot = Vec2.dot(v2, v3);
+    // Ray is parallel to line segment.
+    if (Math.abs(dot) < 1e-6) {
+        return undefined;
+    }
+    const t1 = Vec2.cross(v2, v1) / dot;
+    const t2 = Vec2.dot(v1, v3) / dot;
+    if (t1 >= 0.0 && (t2 >= 0.0 && t2 <= 1.0)) {
+        return t1;
+    }
+    return undefined;
+}
+//# sourceMappingURL=geometry.js.map

package/lib/math/mat3.d.ts

@@ -0,0 +1,2 @@
+export * from '@cyclonium/math/mat3';
+//# sourceMappingURL=mat3.d.ts.map

package/lib/math/mat3.js

@@ -0,0 +1,2 @@
+export * from '@cyclonium/math/mat3';
+//# sourceMappingURL=mat3.js.map

package/lib/math/number.d.ts

@@ -0,0 +1,2 @@
+export * from '@cyclonium/math/number';
+//# sourceMappingURL=number.d.ts.map

package/lib/math/number.js

@@ -0,0 +1,2 @@
+export * from '@cyclonium/math/number';
+//# sourceMappingURL=number.js.map

package/lib/math/ray.d.ts

@@ -0,0 +1,12 @@
+import { Vec2 } from './vec2.ts';
+export declare class Ray2D {
+    constructor(origin: Vec2, direction: Vec2);
+    get origin(): Vec2;
+    set origin(origin: Vec2);
+    get direction(): Vec2;
+    set direction(direction: Vec2);
+    at(distance: number): Vec2;
+    private _origin;
+    private _direction;
+}
+//# sourceMappingURL=ray.d.ts.map

package/lib/math/ray.js

@@ -0,0 +1,26 @@
+import { Vec2 } from "./vec2.js";
+export class Ray2D {
+    constructor(origin, direction) {
+        this.origin = origin.clone();
+        this.direction = direction.normalize();
+    }
+    get origin() {
+        return this._origin;
+    }
+    set origin(origin) {
+        Vec2.assign(this._origin, origin);
+    }
+    get direction() {
+        return this._direction;
+    }
+    set direction(direction) {
+        Vec2.assign(this._direction, direction);
+        this._direction.normalizeSelf();
+    }
+    at(distance) {
+        return this.origin.addMulScalar(this.direction, distance);
+    }
+    _origin = new Vec2();
+    _direction = new Vec2();
+}
+//# sourceMappingURL=ray.js.map

package/lib/math/transform-2d.d.ts

@@ -0,0 +1,2 @@
+export * from '@cyclonium/math/transform-2d';
+//# sourceMappingURL=transform-2d.d.ts.map

package/lib/math/transform-2d.js

@@ -0,0 +1,2 @@
+export * from '@cyclonium/math/transform-2d';
+//# sourceMappingURL=transform-2d.js.map

package/lib/math/trigonometry.d.ts

@@ -0,0 +1,2 @@
+export * from '@cyclonium/math/trigonometry';
+//# sourceMappingURL=trigonometry.d.ts.map

package/lib/math/trigonometry.js

@@ -0,0 +1,2 @@
+export * from '@cyclonium/math/trigonometry';
+//# sourceMappingURL=trigonometry.js.map

package/lib/math/vec2.d.ts

@@ -0,0 +1,5 @@
+import { Vec2, v2 } from '@cyclonium/math/vec2';
+import * as cc from 'cc';
+export { Vec2, v2 };
+export declare function _toCCVec2(v: Vec2): cc.Vec2;
+//# sourceMappingURL=vec2.d.ts.map

package/lib/math/vec2.js

@@ -0,0 +1,17 @@
+import { Vec2, v2 } from '@cyclonium/math/vec2';
+import { applyLegacyDecorators } from "../decorator/legacy/apply-legacy-decorators.js";
+import { editable, cycloBuiltinClass, serializable } from "../decorator/legacy/legacy-general-decorator.js";
+import * as cc from 'cc';
+applyLegacyDecorators(Vec2, {
+    classDecorators: [cycloBuiltinClass('Vec2')],
+    // @ts-expect-error
+    propertyDecorators: {
+        x: [serializable, editable],
+        y: [serializable, editable],
+    },
+});
+export { Vec2, v2 };
+export function _toCCVec2(v) {
+    return cc.v2(v.x, v.y);
+}
+//# sourceMappingURL=vec2.js.map

package/lib/utils/assert.d.ts

@@ -0,0 +1,5 @@
+export declare function assert(value: unknown, message?: string): asserts value;
+export declare namespace assert {
+    function unreachable(): never;
+}
+//# sourceMappingURL=assert.d.ts.map

package/lib/utils/assert.js

@@ -0,0 +1,14 @@
+export function assert(value, message) {
+    if (!value) {
+        debugger;
+        throw new Error(`Assertion failed: ${message ?? '<no-message>'}`);
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-namespace
+(function (assert) {
+    function unreachable() {
+        assert(false, 'Unreachable');
+    }
+    assert.unreachable = unreachable;
+})(assert || (assert = {}));
+//# sourceMappingURL=assert.js.map

package/lib/utils/enum.d.ts

@@ -0,0 +1,3 @@
+export declare function markEnum<TEnum extends Record<string, unknown>>(e: TEnum): void;
+export declare function DynamicEnum<TEnum extends Record<string, unknown>>(e: TEnum): TEnum;
+//# sourceMappingURL=enum.d.ts.map

package/lib/utils/enum.js

@@ -0,0 +1,15 @@
+import { ccenum, Enum } from 'cc';
+export function markEnum(e) {
+    ccenum(e);
+}
+export function DynamicEnum(e) {
+    markEnum(e);
+    return new Proxy(e, {
+        set(target, p, newValue, receiver) {
+            const returnValue = Reflect.set(target, p, newValue, receiver);
+            Enum.update(target);
+            return returnValue;
+        },
+    });
+}
+//# sourceMappingURL=enum.js.map

package/lib/utils/inheritance.d.ts

@@ -0,0 +1,2 @@
+export declare function isSubClassOfInclusive<T extends new (...args: never[]) => unknown>(subClass: Function, superClass: T): subClass is T;
+//# sourceMappingURL=inheritance.d.ts.map

package/lib/utils/inheritance.js

@@ -0,0 +1,5 @@
+/* eslint-disable @typescript-eslint/no-unsafe-function-type */
+export function isSubClassOfInclusive(subClass, superClass) {
+    return subClass === superClass || subClass.prototype instanceof superClass;
+}
+//# sourceMappingURL=inheritance.js.map

package/lib/utils/logger.d.ts

@@ -0,0 +1,7 @@
+export declare const logger: {
+    verbose: (...args: unknown[]) => unknown;
+    info: (...args: unknown[]) => unknown;
+    warn: (...args: unknown[]) => unknown;
+    error: (...args: unknown[]) => unknown;
+};
+//# sourceMappingURL=logger.d.ts.map

package/lib/utils/logger.js

@@ -0,0 +1,19 @@
+import { director } from 'cc';
+export const logger = {
+    verbose: wrapLogMethod(console.debug.bind(console)),
+    info: wrapLogMethod(console.log.bind(console)),
+    warn: wrapLogMethod(console.warn.bind(console)),
+    error: wrapLogMethod(console.error.bind(console)),
+};
+function wrapLogMethod(method) {
+    return (...args) => {
+        const prefix = `[${director.getTotalFrames()}]`;
+        if (typeof args[0] === 'string') {
+            return method(`${prefix}${args[0]}`, ...args.slice(1));
+        }
+        else {
+            return method(prefix, ...args);
+        }
+    };
+}
+//# sourceMappingURL=logger.js.map

package/lib/utils/raw.d.ts

@@ -0,0 +1,6 @@
+export declare class Raw<T> {
+    data: T;
+    constructor(data: T);
+}
+export declare const dumpRaw: MethodDecorator;
+//# sourceMappingURL=raw.d.ts.map

package/lib/utils/raw.js

@@ -0,0 +1,26 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { cycloBuiltinClass } from "../export/internal.js";
+let Raw = class Raw {
+    data;
+    constructor(data) {
+        this.data = data;
+    }
+};
+Raw = __decorate([
+    cycloBuiltinClass('_Raw')
+], Raw);
+export { Raw };
+export const dumpRaw = (target, propertyKey, descriptor) => {
+    const get = descriptor.get;
+    if (get) {
+        descriptor.get = function () {
+            return new Raw(get.call(this));
+        };
+    }
+};
+//# sourceMappingURL=raw.js.map