@cyclonium/core 0.0.104 → 1.0.0

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

@@ -7,8 +7,8 @@ export declare enum TransformFlag {
     scale = 4
 }
 declare class TransformChangeFlags {
-    get token(): boolean;
     frontValue: number;
+    get token(): boolean;
     get backValue(): number;
     reset(): void;
     private _token;

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

@@ -12,7 +12,6 @@ import { Mat3 } from "../math/mat3.js";
 import { mat3FromSRT } from "../math/transform-2d.js";
 import { Vec2 } from "../math/vec2.js";
 import { to0ToPI2 } from "../math/trigonometry.js";
-import { logger } from "../utils/logger.js";
 import { clamp } from "../math/number.js";
 export var TransformFlag;
 (function (TransformFlag) {
@@ -21,10 +20,10 @@ export var TransformFlag;
     TransformFlag[TransformFlag["scale"] = 4] = "scale";
 })(TransformFlag || (TransformFlag = {}));
 class TransformChangeFlags {
+    frontValue = 0;
     get token() {
         return this._token;
     }
-    frontValue = 0;
     get backValue() {
         return this._backValue;
     }

package/lib/decorator/legacy/editable/common.js

@@ -3,6 +3,7 @@ export function createDecoratorForSetEditableMetadata(opts) {
     return (target, propertyKey, descriptor) => {
         const normalizedOptions = {
             ...opts,
+            serializable: false,
         };
         if (normalizedOptions.visible === undefined) {
             if (typeof propertyKey === 'string' && propertyKey.startsWith('_')) {
@@ -10,7 +11,8 @@ export function createDecoratorForSetEditableMetadata(opts) {
                 normalizedOptions.displayName = propertyKey.slice(1);
             }
         }
-        return _decorator.property(normalizedOptions)(target, propertyKey, descriptor);
+        _decorator.property(normalizedOptions)(target, propertyKey, descriptor);
+        _decorator.editable(target, propertyKey, descriptor);
     };
 }
 //# sourceMappingURL=common.js.map

package/lib/decorator/legacy/editable/editable.d.ts

@@ -1,4 +1,4 @@
-import { CCInteger, type CCBoolean, type CCFloat, type CCString } from 'cc';
+import { CCInteger, type CCBoolean, type CCString } from 'cc';
 export interface EditableDecoratorOptions {
     type?: Function | typeof CCInteger;
     min?: number;
@@ -17,7 +17,7 @@ export interface EditableDecoratorOptions {
 }
 declare function editable(options?: EditableDecoratorOptions): PropertyDecorator;
 declare function editable(type?: Function): PropertyDecorator;
-declare function editable(type?: typeof CCInteger | typeof CCBoolean | typeof CCFloat | typeof CCString): PropertyDecorator;
+declare function editable(type?: typeof CCInteger | typeof CCBoolean | typeof CCString): PropertyDecorator;
 declare function editable(target: object, propertyKey: string | symbol): void;
 export { editable };
 //# sourceMappingURL=editable.d.ts.map

package/lib/decorator/legacy/editable/editable.js

@@ -50,9 +50,7 @@ function editableWithOptions(options) {
                 modifiedOptions.min = 0;
                 modifiedOptions.max = Math.PI * 2;
             }
-            if (modifiedOptions.step === undefined) {
-                modifiedOptions.step = 1;
-            }
+            modifiedOptions.step ??= 1;
         }
         createDecoratorForSetEditableMetadata(modifiedOptions)(...args);
     };

package/lib/decorator/legacy/legacy-component-decorator.d.ts

@@ -1,11 +1,11 @@
-import { Component } from 'cc';
+import { Component, type Constructor } from 'cc';
 import { CycloComponent } from '../../framework/component.ts';
 export declare function executionOrder(order: number): ClassDecorator;
 export declare namespace executionOrder {
     function lateThan(component: CycloComponentClass): ClassDecorator;
 }
 export declare const executeInEditMode: ((value?: boolean) => ClassDecorator) & ClassDecorator;
-export declare function requiresComponent<T extends Component>(componentType: new (...args: never[]) => T): MethodDecorator;
+export declare function requiresComponent<T extends Component>(componentType: Constructor<T>): MethodDecorator;
 type CycloComponentClass = new (...args: never[]) => CycloComponent;
 export {};
 //# sourceMappingURL=legacy-component-decorator.d.ts.map

package/lib/decorator/legacy/legacy-component-decorator.js

@@ -2,7 +2,6 @@
 import { _decorator, Component } from 'cc';
 import { CycloComponent } from "../../framework/component.js";
 import { getExecutionOrder, setExecutionOrder } from "../../framework/execution-order.js";
-import { logger } from "../../utils/logger.js";
 export function executionOrder(order) {
     return defineComponentDecorator((target) => {
         setExecutionOrder(target, order);
@@ -36,17 +35,16 @@ function addRequiredComponent(target, componentType) {
 export function requiresComponent(componentType) {
     return defineComponentMethodDecorator((target, propertyKey, descriptor) => {
         addRequiredComponent(target, componentType);
-        const { get, set, value, ...remain } = descriptor;
-        if (set) {
+        if (descriptor.set !== undefined) {
             throw new Error(`Property ${String(propertyKey)} of should not has set`);
         }
-        if (value !== undefined) {
+        if (descriptor.value !== undefined) {
             throw new Error(`Property ${String(propertyKey)} of should not has value`);
         }
         return {
-            ...remain,
+            configurable: descriptor.configurable,
+            enumerable: descriptor.enumerable,
             get() {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 const component = this.getComponent(componentType);
                 if (!component) {
                     throw new Error(`Component ${componentType.name} is not found.`);
@@ -82,7 +80,7 @@ function defineComponentDecoratorWithOptionalBoolean(decorate) {
 function defineComponentMethodDecorator(decorate) {
     return (target, propertyKey, descriptor) => {
         if (!(target instanceof CycloComponent)) {
-            throw new Error(`Class ${target} is not a subclass of CycloComponent.`);
+            throw new Error(`Class ${String(target)} is not a subclass of CycloComponent.`);
         }
         return decorate(target, propertyKey, descriptor);
     };

package/lib/decorator/legacy/legacy-general-decorator.d.ts

@@ -16,7 +16,7 @@ export declare function createScopedCycloClassDecorator(opts: {
 declare const cycloClass: CycloClassDecorator;
 declare const cycloBuiltinClass: CycloClassDecorator;
 export { cycloClass, cycloBuiltinClass };
-export declare const serializable: typeof _decorator.property;
+export declare const stored: PropertyDecorator;
 /**
  * Marks that the property's default value might vary between instances.
  * @description

package/lib/decorator/legacy/legacy-general-decorator.js

@@ -44,7 +44,7 @@ const cycloBuiltinClass = createScopedCycloClassDecorator({
     scope: 'cyclo.',
 });
 export { cycloClass, cycloBuiltinClass };
-export const serializable = _decorator.property;
+export const stored = _decorator.serializable;
 /**
  * Marks that the property's default value might vary between instances.
  * @description

package/lib/decorator/legacy/utils.d.ts

@@ -1,6 +1,6 @@
-export interface ShortenPropertyDecorator<TArgs extends any[]> {
+export interface ShortenPropertyDecorator<TArgs extends unknown[]> {
     (...args: TArgs): PropertyDecorator;
-    (target: Object, propertyKey: string | symbol): void;
+    (target: object, propertyKey: string | symbol): void;
 }
-export declare function defineShortenPropertyDecorator<TArgs extends any[]>(decorator: (...args: TArgs) => PropertyDecorator, ...defaultArgs: TArgs): ShortenPropertyDecorator<TArgs>;
+export declare function defineShortenPropertyDecorator<TArgs extends unknown[]>(decorator: (...args: TArgs) => PropertyDecorator, ...defaultArgs: TArgs): ShortenPropertyDecorator<TArgs>;
 //# sourceMappingURL=utils.d.ts.map

package/lib/decorator/legacy/utils.js

@@ -4,7 +4,7 @@ export function defineShortenPropertyDecorator(decorator, ...defaultArgs) {
             // @x()
             return decorator(...defaultArgs);
         }
-        else if (!(typeof args[0] === 'object' && args[0] && typeof args[1] === 'string' || typeof args[1] === 'symbol')) {
+        else if (!((typeof args[0] === 'object' && args[0] && typeof args[1] === 'string') || typeof args[1] === 'symbol')) {
             // @x(opts)
             return decorator(...args);
         }

package/lib/export/internal.d.ts

@@ -1,2 +1,3 @@
 export { cycloBuiltinClass } from '../decorator/legacy/legacy-decorator.ts';
+export { TimeAccumulator } from '../framework/time-accumulator.js';
 //# sourceMappingURL=internal.d.ts.map

package/lib/export/internal.js

@@ -1,2 +1,3 @@
 export { cycloBuiltinClass } from "../decorator/legacy/legacy-decorator.js";
+export { TimeAccumulator } from '../framework/time-accumulator.js';
 //# sourceMappingURL=internal.js.map

package/lib/export/legacy-decorator.d.ts

@@ -1,4 +1,4 @@
-export { designType, editable, editorOnly, cycloClass, createScopedCycloClassDecorator, dynamicDefault, idem, idemBy, serializable, type CycloClassOptions, type CycloClassDecorator, } from '../decorator/legacy/legacy-general-decorator.ts';
+export { designType, editable, editorOnly, cycloClass, createScopedCycloClassDecorator, dynamicDefault, idem, idemBy, stored, type CycloClassOptions, type CycloClassDecorator, } from '../decorator/legacy/legacy-general-decorator.ts';
 export { executionOrder, executeInEditMode, requiresComponent, } from '../decorator/legacy/legacy-component-decorator.ts';
 export { applyLegacyDecorators } from '../decorator/legacy/apply-legacy-decorators.ts';
 //# sourceMappingURL=legacy-decorator.d.ts.map

package/lib/export/legacy-decorator.js

@@ -1,4 +1,4 @@
-export { designType, editable, editorOnly, cycloClass, createScopedCycloClassDecorator, dynamicDefault, idem, idemBy, serializable, } from "../decorator/legacy/legacy-general-decorator.js";
+export { designType, editable, editorOnly, cycloClass, createScopedCycloClassDecorator, dynamicDefault, idem, idemBy, stored, } from "../decorator/legacy/legacy-general-decorator.js";
 export { executionOrder, executeInEditMode, requiresComponent, } from "../decorator/legacy/legacy-component-decorator.js";
 export { applyLegacyDecorators } from "../decorator/legacy/apply-legacy-decorators.js";
 //# sourceMappingURL=legacy-decorator.js.map

package/lib/framework/component.js

@@ -12,6 +12,7 @@ import { addFrameTask, TaskPriority } from "./tasking.js";
 import { CoroutineRunner, stopCoroutine as stopCoroutineRecord } from "./coroutine.js";
 import { retainIf } from '@cyclonium/algorithm/retain-if';
 import { EDITOR_NOT_IN_PREVIEW } from 'cc/env';
+import { TimeAccumulator } from './time-accumulator.js';
 class ComponentScheduler {
     enableComponent(component) {
         const index = this._fixedUpdateRegistry.findIndex(({ component: c }) => c === component);
@@ -110,19 +111,35 @@ let CycloComponent = class CycloComponent extends Component {
     get disablingSignal() {
         return (this._disablingController ??= new AbortController()).signal;
     }
-    onAwake() { }
-    onEnabled() { }
-    onDisabled() { }
+    onAwake() {
+        // Optional lifecycle hook for subclasses.
+    }
+    onEnabled() {
+        // Optional lifecycle hook for subclasses.
+    }
+    onDisabled() {
+        // Optional lifecycle hook for subclasses.
+    }
     onDestroy() {
         this.stopAllCoroutines();
         this._destroyingController?.abort();
         this._destroyingController = undefined;
     }
-    onStart() { }
-    onUpdate(_deltaTime) { }
-    onFixedUpdate(_deltaTime) { }
-    onLateUpdate(_deltaTime) { }
-    onFrameEnd() { }
+    onStart() {
+        // Optional lifecycle hook for subclasses.
+    }
+    onUpdate(_deltaTime) {
+        // Optional lifecycle hook for subclasses.
+    }
+    onFixedUpdate(_deltaTime) {
+        // Optional lifecycle hook for subclasses.
+    }
+    onLateUpdate(_deltaTime) {
+        // Optional lifecycle hook for subclasses.
+    }
+    onFrameEnd() {
+        // Optional lifecycle hook for subclasses.
+    }
     /**
      * Starts a coroutine owned by this component.
      * @param coroutine - Coroutine iterator to start.
@@ -259,27 +276,22 @@ class FixedUpdateTask {
     update(deltaTime) {
         const scene = director.getScene();
         if (!scene) {
-            this._accumulatedTime = 0;
+            this._timeAccumulator.reset();
             return;
         }
-        const fixedTimeStep = this._fixedTimeStep;
+        const timeAccumulator = this._timeAccumulator;
+        const fixedTimeStep = timeAccumulator.timeStep;
         const maxSteps = this.maxSteps;
-        const accumulatedTime = this._accumulatedTime + deltaTime;
-        const expectedSteps = Math.floor(accumulatedTime / fixedTimeStep);
-        const overloading = expectedSteps > maxSteps;
+        const actualSteps = timeAccumulator.advance(deltaTime, maxSteps);
+        const overloading = deltaTime > maxSteps * fixedTimeStep;
         const previousOverloading = this._overloading;
         this._overloading = overloading;
-        let actualSteps = 0;
         if (overloading) {
-            actualSteps = maxSteps;
-            this._accumulatedTime = 0;
             if (overloading !== previousOverloading) {
-                this._emitOverloadingBegin(expectedSteps);
+                this._emitOverloadingBegin();
             }
         }
         else {
-            actualSteps = expectedSteps;
-            this._accumulatedTime = accumulatedTime - actualSteps * fixedTimeStep;
             if (overloading !== previousOverloading) {
                 this._emitOverloadingEnd();
             }
@@ -288,12 +300,10 @@ class FixedUpdateTask {
             globalComponentScheduler.invokeFixedUpdate(fixedTimeStep);
         }
     }
-    _fixedTimeStep = 1 / 60;
-    _accumulatedTime = 0;
+    _timeAccumulator = new TimeAccumulator(1 / 60);
     _overloading = false;
-    _emitOverloadingBegin(expectedSteps) {
+    _emitOverloadingBegin() {
         // todo
-        void expectedSteps;
     }
     _emitOverloadingEnd() {
         // todo
@@ -301,15 +311,17 @@ class FixedUpdateTask {
 }
 if (!EDITOR_NOT_IN_PREVIEW) {
     const fixedUpdatePriority = TaskPriority.before(TaskPriority.predefined.componentsLateUpdate);
+    const coroutineUpdateTask = new CoroutineUpdateTask();
+    const fixedUpdateTask = new FixedUpdateTask();
     addFrameTask({
-        thisArg: new CoroutineUpdateTask(),
+        thisArg: coroutineUpdateTask,
         priority: TaskPriority.between(fixedUpdatePriority, TaskPriority.predefined.componentsLateUpdate),
-        fn: CoroutineUpdateTask.prototype.update,
+        fn: coroutineUpdateTask.update.bind(coroutineUpdateTask),
     });
     addFrameTask({
-        thisArg: new FixedUpdateTask(),
+        thisArg: fixedUpdateTask,
         priority: fixedUpdatePriority,
-        fn: FixedUpdateTask.prototype.update,
+        fn: fixedUpdateTask.update.bind(fixedUpdateTask),
     });
     addFrameTask({
         thisArg: undefined,

package/lib/framework/coroutine.d.ts

@@ -84,13 +84,13 @@ export declare function waitUntil(predicate: CoroutinePredicate): CoroutineInstr
  */
 export declare function waitWhile(predicate: CoroutinePredicate): CoroutineInstruction;
 export declare class CoroutineRunner {
+    get frame(): number;
+    get deltaTime(): number;
+    get empty(): boolean;
     start(coroutine: CoroutineIterator, opts?: StartCoroutineOptions): Coroutine;
     update(deltaTime: number): void;
     stop(handle: Coroutine): void;
     stopAll(): void;
-    get frame(): number;
-    get deltaTime(): number;
-    get empty(): boolean;
     private _records;
     private _frame;
     private _deltaTime;

package/lib/framework/coroutine.js

@@ -52,6 +52,15 @@ export function waitWhile(predicate) {
     };
 }
 export class CoroutineRunner {
+    get frame() {
+        return this._frame;
+    }
+    get deltaTime() {
+        return this._deltaTime;
+    }
+    get empty() {
+        return this._records.length === 0;
+    }
     start(coroutine, opts) {
         const record = new CoroutineRecord(this, coroutine, opts);
         this._records.push(record);
@@ -89,15 +98,6 @@ export class CoroutineRunner {
             this._endPruneDeferral();
         }
     }
-    get frame() {
-        return this._frame;
-    }
-    get deltaTime() {
-        return this._deltaTime;
-    }
-    get empty() {
-        return this._records.length === 0;
-    }
     _records = [];
     _frame = 0;
     _deltaTime = 0;
@@ -191,6 +191,7 @@ class CoroutineRecord {
     _done = false;
     _executing = false;
     _stopping = false;
+    _onAbort = undefined;
     _advance(frame) {
         let result;
         this._executing = true;
@@ -273,6 +274,5 @@ class CoroutineRecord {
         this._signal.removeEventListener('abort', this._onAbort);
         this._onAbort = undefined;
     }
-    _onAbort = undefined;
 }
 //# sourceMappingURL=coroutine.js.map

package/lib/framework/tasking.d.ts

@@ -6,7 +6,7 @@ export declare const TaskPriority: {
     after(priority: number): number;
     between(a: number, b: number): number;
 };
-interface Task<TThis = any> {
+interface Task<TThis> {
     fn: (this: TThis, deltaTime: number) => void;
     thisArg: TThis;
     priority: number;

package/lib/framework/tasking.js

@@ -20,7 +20,10 @@ class TaskCluster {
             return false;
         }
         this._tasks.push({
-            ...task,
+            fn: task.fn,
+            thisArg: task.thisArg,
+            priority: task.priority,
+            execute: (deltaTime) => task.fn.call(task.thisArg, deltaTime),
         });
         this._tasks.sort((a, b) => b.priority - a.priority);
         return true;
@@ -35,7 +38,7 @@ class TaskCluster {
     }
     execute(deltaTime) {
         for (const task of this._tasks) {
-            task.fn.call(task.thisArg, deltaTime);
+            task.execute(deltaTime);
         }
     }
     _tasks = [];

package/lib/framework/time-accumulator.d.ts

@@ -0,0 +1,10 @@
+export declare class TimeAccumulator {
+    constructor(timeStep: number);
+    get timeStep(): number;
+    /** Adds at most `maxSteps` worth of elapsed time and consumes complete steps. */
+    advance(deltaTime: number, maxSteps: number): number;
+    reset(): void;
+    private readonly _timeStep;
+    private _accumulatedTime;
+}
+//# sourceMappingURL=time-accumulator.d.ts.map

package/lib/framework/time-accumulator.js

@@ -0,0 +1,29 @@
+export class TimeAccumulator {
+    constructor(timeStep) {
+        this._timeStep = timeStep;
+    }
+    get timeStep() {
+        return this._timeStep;
+    }
+    /** Adds at most `maxSteps` worth of elapsed time and consumes complete steps. */
+    advance(deltaTime, maxSteps) {
+        const timeStep = this._timeStep;
+        const maximumDeltaTime = maxSteps * timeStep;
+        const acceptedDeltaTime = Math.min(deltaTime, maximumDeltaTime);
+        const accumulatedTime = this._accumulatedTime + acceptedDeltaTime;
+        const steps = Math.min(countCompleteSteps(accumulatedTime, timeStep), maxSteps);
+        this._accumulatedTime = Math.max(accumulatedTime - steps * timeStep, 0);
+        return steps;
+    }
+    reset() {
+        this._accumulatedTime = 0;
+    }
+    _timeStep;
+    _accumulatedTime = 0;
+}
+function countCompleteSteps(accumulatedTime, timeStep) {
+    const stepRatio = accumulatedTime / timeStep;
+    const tolerance = Number.EPSILON * Math.max(Math.abs(stepRatio), 1) * 4;
+    return Math.floor(stepRatio + tolerance);
+}
+//# sourceMappingURL=time-accumulator.js.map

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

@@ -1,13 +1,13 @@
 import { Bounds2D } from '@cyclonium/math/bounds-2d';
-import { applyLegacyDecorators, serializable, editable } from "../export/legacy-decorator.js";
+import { applyLegacyDecorators, stored, 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],
+        // @ts-expect-error -- Legacy decorators intentionally target Bounds2D's private serialized fields.
+        _min: [stored, editable],
+        _max: [stored, editable],
     },
 });
 //# sourceMappingURL=bounds-2d.js.map

package/lib/math/vec2.js

@@ -1,13 +1,13 @@
 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 { editable, cycloBuiltinClass, stored } from "../decorator/legacy/legacy-general-decorator.js";
 import * as cc from 'cc';
 applyLegacyDecorators(Vec2, {
     classDecorators: [cycloBuiltinClass('Vec2')],
-    // @ts-expect-error
+    // @ts-expect-error -- Legacy decorators require metadata for Vec2 fields declared by another package.
     propertyDecorators: {
-        x: [serializable, editable],
-        y: [serializable, editable],
+        x: [stored, editable],
+        y: [stored, editable],
     },
 });
 export { Vec2, v2 };

package/lib/utils/assert.js

@@ -1,6 +1,5 @@
 export function assert(value, message) {
     if (!value) {
-        debugger;
         throw new Error(`Assertion failed: ${message ?? '<no-message>'}`);
     }
 }

package/lib/utils/raw.js

@@ -15,7 +15,9 @@ Raw = __decorate([
     cycloBuiltinClass('_Raw')
 ], Raw);
 export { Raw };
-export const dumpRaw = (target, propertyKey, descriptor) => {
+export const dumpRaw = (_target, _propertyKey, descriptor) => {
+    // The getter is deliberately invoked later with the decorated instance as its receiver.
+    // eslint-disable-next-line @typescript-eslint/unbound-method
     const get = descriptor.get;
     if (get) {
         descriptor.get = function () {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cyclonium/core",
-  "version": "0.0.104",
+  "version": "1.0.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/shrinktofit/cyclonium",