@cyclonium/core 0.0.100

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

@@ -0,0 +1,67 @@
+import { CycloComponent } from '../framework/component.ts';
+import { Mat3 } from '../math/mat3.ts';
+import { Vec2 } from '../math/vec2.ts';
+export declare enum TransformFlag {
+    position = 1,
+    rotation = 2,
+    scale = 4
+}
+declare class TransformChangeFlags {
+    get token(): boolean;
+    frontValue: number;
+    get backValue(): number;
+    reset(): void;
+    private _token;
+    private _backValue;
+}
+export declare class TransformChangeFlagsObserver {
+    observe(transform: Transform2DComponent): void;
+    sync(): number;
+    private _token;
+    private _flags;
+}
+export declare class Transform2DComponent extends CycloComponent {
+    static DEFAULT_FORWARD: Readonly<Vec2>;
+    static DEFAULT_UP: Readonly<Vec2>;
+    static DEFAULT_RIGHT: Readonly<Vec2>;
+    get position(): Vec2;
+    set position(value: Vec2);
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get localPosition(): Vec2;
+    set localPosition(value: Vec2);
+    get localX(): number;
+    set localX(value: number);
+    get localY(): number;
+    set localY(value: number);
+    get rotation(): number;
+    set rotation(value: number);
+    get localRotation(): number;
+    set localRotation(value: number);
+    get scale(): Vec2;
+    set scale(value: Vec2 | number);
+    get localScale(): Vec2;
+    set localScale(value: Vec2 | number);
+    get forward(): Vec2;
+    set forward(value: Vec2);
+    get up(): Vec2;
+    set up(value: Vec2);
+    get right(): Vec2;
+    set right(value: Vec2);
+    get matrix(): Mat3;
+    get changeFlags(): TransformChangeFlags;
+    rotateAround(point: Vec2, angle: number): void;
+    protected onFrameEnd(): void;
+    private _position;
+    private _scale;
+    private _localPosition;
+    private _localScale;
+    private _forward;
+    private _matrix;
+    private _changeFlags;
+    private _setChangeFlag;
+}
+export {};
+//# sourceMappingURL=transform-2d-component.d.ts.map

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

@@ -0,0 +1,206 @@
+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;
+};
+var Transform2DComponent_1;
+import { Quat, Vec3 } from 'cc';
+import { editable, cycloBuiltinClass } from "../decorator/legacy/legacy-decorator.js";
+import { CycloComponent } from "../framework/component.js";
+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) {
+    TransformFlag[TransformFlag["position"] = 1] = "position";
+    TransformFlag[TransformFlag["rotation"] = 2] = "rotation";
+    TransformFlag[TransformFlag["scale"] = 4] = "scale";
+})(TransformFlag || (TransformFlag = {}));
+class TransformChangeFlags {
+    get token() {
+        return this._token;
+    }
+    frontValue = 0;
+    get backValue() {
+        return this._backValue;
+    }
+    reset() {
+        this._token = !this._token;
+        this._backValue = this.frontValue;
+        this.frontValue = 0;
+    }
+    _token = false;
+    _backValue = 0;
+}
+export class TransformChangeFlagsObserver {
+    observe(transform) {
+        const flags = transform.changeFlags;
+        this._token = flags.token;
+        this._flags = flags;
+    }
+    sync() {
+        if (this._token === this._flags.token) {
+            return this._flags.frontValue;
+        }
+        else {
+            this._token = this._flags.token;
+            return this._flags.backValue | this._flags.frontValue;
+        }
+    }
+    _token = false;
+    _flags = new TransformChangeFlags();
+}
+let Transform2DComponent = class Transform2DComponent extends CycloComponent {
+    static { Transform2DComponent_1 = this; }
+    static DEFAULT_FORWARD = Vec2.UNIT_X;
+    static DEFAULT_UP = Vec2.UNIT_Y;
+    static DEFAULT_RIGHT = Vec2.UNIT_X;
+    get position() {
+        return Vec2.set(this._position, this.node.worldPosition.x, this.node.worldPosition.y);
+    }
+    set position(value) {
+        Vec2.assign(this._position, value);
+        this.node.worldPosition = new Vec3(value.x, value.y, this.node.worldPosition.z);
+        this._setChangeFlag(TransformFlag.position);
+    }
+    get x() {
+        return this.node.worldPosition.x;
+    }
+    set x(value) {
+        this.node.worldPosition = new Vec3(value, this.node.worldPosition.y, this.node.worldPosition.z);
+        this._setChangeFlag(TransformFlag.position);
+    }
+    get y() {
+        return this.node.worldPosition.y;
+    }
+    set y(value) {
+        this.node.worldPosition = new Vec3(this.node.worldPosition.x, value, this.node.worldPosition.z);
+        this._setChangeFlag(TransformFlag.position);
+    }
+    get localPosition() {
+        return Vec2.set(this._localPosition, this.node.position.x, this.node.position.y);
+    }
+    set localPosition(value) {
+        Vec2.assign(this._localPosition, value);
+        this.node.position = new Vec3(value.x, value.y, this.node.position.z);
+        this._setChangeFlag(TransformFlag.position);
+    }
+    get localX() {
+        return this.node.position.x;
+    }
+    set localX(value) {
+        this.node.position = new Vec3(value, this.node.position.y, this.node.position.z);
+        this._setChangeFlag(TransformFlag.position);
+    }
+    get localY() {
+        return this.node.position.y;
+    }
+    set localY(value) {
+        this.node.position = new Vec3(this.node.position.x, value, this.node.position.z);
+        this._setChangeFlag(TransformFlag.position);
+    }
+    get rotation() {
+        return to0ToPI2(getZRotation(this.node.worldRotation));
+    }
+    set rotation(value) {
+        this.node.worldRotation = Quat.fromAxisAngle(new Quat(), Vec3.UNIT_Z, value);
+        this._setChangeFlag(TransformFlag.rotation);
+    }
+    get localRotation() {
+        return to0ToPI2(getZRotation(this.node.rotation));
+    }
+    set localRotation(value) {
+        this.node.rotation = Quat.fromAxisAngle(new Quat(), Vec3.UNIT_Z, value);
+        this._setChangeFlag(TransformFlag.rotation);
+    }
+    get scale() {
+        return Vec2.set(this._scale, this.node.worldScale.x, this.node.worldScale.y);
+    }
+    set scale(value) {
+        this.node.worldScale = typeof value === 'number' ? new Vec3(value, value, this.node.worldScale.z) : new Vec3(value.x, value.y, this.node.worldScale.z);
+        this._setChangeFlag(TransformFlag.scale);
+    }
+    get localScale() {
+        return Vec2.set(this._localScale, this.node.scale.x, this.node.scale.y);
+    }
+    set localScale(value) {
+        this.node.scale = typeof value === 'number' ? new Vec3(value, value, this.node.scale.z) : new Vec3(value.x, value.y, this.node.scale.z);
+        this._setChangeFlag(TransformFlag.scale);
+    }
+    get forward() {
+        const f = Vec3.transformQuat(new Vec3(), new Vec3(Transform2DComponent_1.DEFAULT_FORWARD.x, Transform2DComponent_1.DEFAULT_FORWARD.y, 0), this.node.worldRotation);
+        return Vec2.set(this._forward, f.x, f.y);
+    }
+    set forward(value) {
+        const angle = Vec2.signedAngle(Transform2DComponent_1.DEFAULT_FORWARD, value);
+        this.rotation = angle;
+    }
+    get up() {
+        return Transform2DComponent_1.DEFAULT_UP.rotate(this.rotation);
+    }
+    set up(value) {
+        this.rotation = Vec2.signedAngle(Transform2DComponent_1.DEFAULT_UP, value);
+    }
+    get right() {
+        return Transform2DComponent_1.DEFAULT_RIGHT.rotate(this.rotation);
+    }
+    set right(value) {
+        this.rotation = Vec2.signedAngle(Transform2DComponent_1.DEFAULT_RIGHT, value);
+    }
+    get matrix() {
+        return mat3FromSRT(this.position, this.rotation, this.scale, this._matrix);
+    }
+    get changeFlags() {
+        return this._changeFlags;
+    }
+    rotateAround(point, angle) {
+        const dx = this.position.x - point.x;
+        const dy = this.position.y - point.y;
+        const rotatedX = dx * Math.cos(angle) - dy * Math.sin(angle);
+        const rotatedY = dx * Math.sin(angle) + dy * Math.cos(angle);
+        this.position = new Vec2(point.x + rotatedX, point.y + rotatedY);
+        this.rotation += angle;
+        this._setChangeFlag(TransformFlag.position | TransformFlag.rotation);
+    }
+    onFrameEnd() {
+        this._changeFlags.reset();
+    }
+    _position = new Vec2();
+    _scale = new Vec2(1, 1);
+    _localPosition = new Vec2();
+    _localScale = new Vec2(1, 1);
+    _forward = new Vec2();
+    _matrix = new Mat3(Mat3.IDENTITY);
+    _changeFlags = new TransformChangeFlags();
+    _setChangeFlag(mask) {
+        this._changeFlags.frontValue |= mask;
+    }
+};
+__decorate([
+    editable
+], Transform2DComponent.prototype, "localPosition", null);
+__decorate([
+    editable({ radian: true })
+], Transform2DComponent.prototype, "localRotation", null);
+__decorate([
+    editable
+], Transform2DComponent.prototype, "localScale", null);
+Transform2DComponent = Transform2DComponent_1 = __decorate([
+    cycloBuiltinClass('Transform2DComponent')
+], Transform2DComponent);
+export { Transform2DComponent };
+function getZRotation(quat) {
+    const { z, w } = quat;
+    const halfTheta = Math.acos(clamp(w, -1, 1));
+    if (halfTheta === 0) {
+        return 0;
+    }
+    const sinSign = Math.sign(halfTheta);
+    const axisSign = sinSign * Math.sign(z);
+    return axisSign * halfTheta * 2;
+}
+//# sourceMappingURL=transform-2d-component.js.map

package/lib/decorator/legacy/apply-legacy-decorators.d.ts

@@ -0,0 +1,5 @@
+export declare function applyLegacyDecorators<T extends object>(targetClass: new (...args: never[]) => T, options: {
+    classDecorators?: ClassDecorator[];
+    propertyDecorators?: Partial<Record<Extract<keyof T, string>, PropertyDecorator[]>>;
+}): void;
+//# sourceMappingURL=apply-legacy-decorators.d.ts.map

package/lib/decorator/legacy/apply-legacy-decorators.js

@@ -0,0 +1,12 @@
+export function applyLegacyDecorators(targetClass, options) {
+    const { classDecorators, propertyDecorators } = options;
+    if (propertyDecorators) {
+        Object.entries(propertyDecorators).forEach(([propertyName, decorators]) => {
+            decorators.forEach((decorator) => decorator(targetClass.prototype, propertyName));
+        });
+    }
+    if (classDecorators) {
+        classDecorators.forEach((decorator) => decorator(targetClass));
+    }
+}
+//# sourceMappingURL=apply-legacy-decorators.js.map

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

@@ -0,0 +1,3 @@
+import { _decorator } from 'cc';
+export declare function createDecoratorForSetEditableMetadata(opts: Parameters<typeof _decorator.property>[0]): PropertyDecorator;
+//# sourceMappingURL=common.d.ts.map

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

@@ -0,0 +1,16 @@
+import { _decorator } from 'cc';
+export function createDecoratorForSetEditableMetadata(opts) {
+    return (target, propertyKey, descriptor) => {
+        const normalizedOptions = {
+            ...opts,
+        };
+        if (normalizedOptions.visible === undefined) {
+            if (typeof propertyKey === 'string' && propertyKey.startsWith('_')) {
+                normalizedOptions.visible = true;
+                normalizedOptions.displayName = propertyKey.slice(1);
+            }
+        }
+        return _decorator.property(normalizedOptions)(target, propertyKey, descriptor);
+    };
+}
+//# sourceMappingURL=common.js.map

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

@@ -0,0 +1,23 @@
+import { CCInteger, type CCBoolean, type CCFloat, type CCString } from 'cc';
+export interface EditableDecoratorOptions {
+    type?: Function | typeof CCInteger;
+    min?: number;
+    max?: number;
+    step?: number;
+    slide?: boolean;
+    /** @deprecated Use `radians` instead. */
+    radian?: boolean;
+    radians?: boolean;
+    unit?: string;
+    visible?: boolean | (() => boolean);
+    group?: string;
+    override?: boolean;
+    readonly?: boolean;
+    tooltip?: string;
+}
+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(target: object, propertyKey: string | symbol): void;
+export { editable };
+//# sourceMappingURL=editable.d.ts.map

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

@@ -0,0 +1,61 @@
+/* eslint-disable @typescript-eslint/no-unsafe-function-type */
+import { CCInteger } from 'cc';
+import { isSubClassOfInclusive } from "../../../utils/inheritance.js";
+import { logger } from "../../../utils/logger.js";
+import { createDecoratorForSetEditableMetadata } from "./common.js";
+function editable(...args) {
+    if (args.length === 0) {
+        // `@editable()`
+        return editableWithOptions({});
+    }
+    else if (args.length === 1) {
+        const args0 = args[0];
+        if (typeof args0 === 'object' && args0) {
+            if (args0.constructor === CCInteger.constructor) {
+                // `@editable(CCInteger)`
+                return editableWithOptions({
+                    type: args0,
+                });
+            }
+            // `@editable(options)`
+            return editableWithOptions(args0);
+        }
+        else if (typeof args0 === 'function') {
+            if (isSubClassOfInclusive(args0, Array)) {
+                // https://forum.cocos.org/t/topic/165943
+                logger.warn(`@editable(Array) is not supported.`);
+            }
+            // `@editable(Node)`
+            return editableWithOptions({
+                type: args0,
+            });
+        }
+        else {
+            throw new Error(`Invalid @editable() arguments.`);
+        }
+    }
+    else {
+        // `@editable`
+        return editableWithOptions({})(...args);
+    }
+}
+function editableWithOptions(options) {
+    return (...args) => {
+        const modifiedOptions = { ...options };
+        if (modifiedOptions.radians !== undefined) {
+            modifiedOptions.radian = modifiedOptions.radians;
+        }
+        if (modifiedOptions.radian) {
+            if (modifiedOptions.min === undefined && modifiedOptions.max === undefined) {
+                modifiedOptions.min = 0;
+                modifiedOptions.max = Math.PI * 2;
+            }
+            if (modifiedOptions.step === undefined) {
+                modifiedOptions.step = 1;
+            }
+        }
+        createDecoratorForSetEditableMetadata(modifiedOptions)(...args);
+    };
+}
+export { editable };
+//# sourceMappingURL=editable.js.map

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

@@ -0,0 +1,11 @@
+import { Component } 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;
+type CycloComponentClass = new (...args: never[]) => CycloComponent;
+export {};
+//# sourceMappingURL=legacy-component-decorator.d.ts.map

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

@@ -0,0 +1,91 @@
+/* eslint-disable @typescript-eslint/no-unsafe-function-type */
+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);
+    });
+}
+// eslint-disable-next-line @typescript-eslint/no-namespace
+(function (executionOrder) {
+    function lateThan(component) {
+        return defineComponentDecorator((target) => {
+            setExecutionOrder(target, getExecutionOrder(component) + 1);
+        });
+    }
+    executionOrder.lateThan = lateThan;
+})(executionOrder || (executionOrder = {}));
+export const executeInEditMode = defineComponentDecoratorWithOptionalBoolean((target, value) => {
+    _decorator.executeInEditMode(value)(target);
+});
+function addRequiredComponent(target, componentType) {
+    let _requireComponent = Reflect.getOwnPropertyDescriptor(target.constructor, '_requireComponent')?.value;
+    if (_requireComponent === undefined) {
+        _requireComponent = [];
+        Reflect.defineProperty(target.constructor, '_requireComponent', {
+            value: _requireComponent,
+            writable: true,
+            enumerable: true,
+            configurable: true,
+        });
+    }
+    _requireComponent.push(componentType);
+}
+export function requiresComponent(componentType) {
+    return defineComponentMethodDecorator((target, propertyKey, descriptor) => {
+        addRequiredComponent(target, componentType);
+        const { get, set, value, ...remain } = descriptor;
+        if (set) {
+            throw new Error(`Property ${String(propertyKey)} of should not has set`);
+        }
+        if (value !== undefined) {
+            throw new Error(`Property ${String(propertyKey)} of should not has value`);
+        }
+        return {
+            ...remain,
+            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.`);
+                }
+                return component;
+            },
+        };
+    });
+}
+function defineComponentDecorator(decorate) {
+    return (target) => {
+        if (!(target.prototype instanceof CycloComponent)) {
+            throw new Error(`Class ${target.name} is not a subclass of CycloComponent.`);
+        }
+        decorate(target);
+    };
+}
+function defineComponentDecoratorWithOptionalBoolean(decorate) {
+    return ((...args) => {
+        const arg0 = args[0];
+        if (typeof arg0 === 'boolean' || arg0 === undefined) {
+            return defineComponentDecorator((target) => {
+                decorate(target, arg0);
+            });
+        }
+        else {
+            return defineComponentDecorator((target) => {
+                decorate(target);
+            })(...args);
+        }
+    });
+}
+function defineComponentMethodDecorator(decorate) {
+    return (target, propertyKey, descriptor) => {
+        if (!(target instanceof CycloComponent)) {
+            throw new Error(`Class ${target} is not a subclass of CycloComponent.`);
+        }
+        return decorate(target, propertyKey, descriptor);
+    };
+}
+;
+//# sourceMappingURL=legacy-component-decorator.js.map

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

@@ -0,0 +1,3 @@
+export * from './legacy-general-decorator.ts';
+export * from './legacy-component-decorator.ts';
+//# sourceMappingURL=legacy-decorator.d.ts.map

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

@@ -0,0 +1,3 @@
+export * from "./legacy-general-decorator.js";
+export * from "./legacy-component-decorator.js";
+//# sourceMappingURL=legacy-decorator.js.map

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

@@ -0,0 +1,32 @@
+import { _decorator } from 'cc';
+import { editable } from './editable/editable.ts';
+export { editable };
+export interface CycloClassOptions {
+    name?: string;
+    abstract?: boolean;
+}
+export interface CycloClassDecorator {
+    (options?: CycloClassOptions): ClassDecorator;
+    (name?: string): ClassDecorator;
+    <TFunction extends Function>(target: TFunction): TFunction | void;
+}
+export declare function createScopedCycloClassDecorator(opts: {
+    scope: string;
+}): CycloClassDecorator;
+declare const cycloClass: CycloClassDecorator;
+declare const cycloBuiltinClass: CycloClassDecorator;
+export { cycloClass, cycloBuiltinClass };
+export declare const serializable: typeof _decorator.property;
+/**
+ * Marks that the property's default value might vary between instances.
+ * @description
+ * Use this for dynamic initializers such as `_time = Math.random()`.
+ * Cocos will avoid treating that initializer result as a reusable default, for
+ * example when stripping default values during serialization.
+ */
+export declare const dynamicDefault: PropertyDecorator;
+export declare const designType: typeof _decorator.type;
+export declare const editorOnly: (...args: Parameters<PropertyDecorator>) => void;
+export declare const idem: MethodDecorator;
+export declare function idemBy<T>(equals: (a: T, b: T) => boolean): MethodDecorator;
+//# sourceMappingURL=legacy-general-decorator.d.ts.map

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

@@ -0,0 +1,94 @@
+/* eslint-disable @typescript-eslint/no-unsafe-function-type */
+import { _decorator, CCClass, Component } from 'cc';
+import { editable } from "./editable/editable.js";
+export { editable };
+const dynamicDefaultProperties = new WeakMap();
+export function createScopedCycloClassDecorator(opts) {
+    const { scope } = opts;
+    function cycloClass(...args) {
+        if (args.length === 0) {
+            return cycloClassWithOptions(scope);
+        }
+        else if (typeof args[0] === 'string') {
+            return cycloClassWithOptions(scope, { name: args[0] });
+        }
+        else if (typeof args[0] === 'object' && args[0]) {
+            return cycloClassWithOptions(scope, args[0]);
+        }
+        else {
+            return cycloClassWithOptions(scope)(...args);
+        }
+    }
+    return cycloClass;
+}
+function cycloClassWithOptions(scope, options) {
+    return (target) => {
+        const name = options?.name ?? target.name;
+        if (!(options?.abstract) && target.prototype instanceof Component) {
+            _decorator.menu(`${scope}/${name}`)(target);
+        }
+        _decorator.ccclass(typeof name === 'string' ? `${scope}${name}` : name)(target);
+        const propertyNames = dynamicDefaultProperties.get(target.prototype);
+        if (propertyNames) {
+            for (const propertyName of propertyNames) {
+                CCClass.Attr.setClassAttr(target, propertyName, 'default', undefined);
+            }
+            dynamicDefaultProperties.delete(target.prototype);
+        }
+    };
+}
+const cycloClass = createScopedCycloClassDecorator({
+    scope: '',
+});
+const cycloBuiltinClass = createScopedCycloClassDecorator({
+    scope: 'cyclo.',
+});
+export { cycloClass, cycloBuiltinClass };
+export const serializable = _decorator.property;
+/**
+ * Marks that the property's default value might vary between instances.
+ * @description
+ * Use this for dynamic initializers such as `_time = Math.random()`.
+ * Cocos will avoid treating that initializer result as a reusable default, for
+ * example when stripping default values during serialization.
+ */
+export const dynamicDefault = (target, propertyKey) => {
+    if (typeof propertyKey !== 'string') {
+        return;
+    }
+    let propertyNames = dynamicDefaultProperties.get(target);
+    if (!propertyNames) {
+        propertyNames = new Set();
+        dynamicDefaultProperties.set(target, propertyNames);
+    }
+    propertyNames.add(propertyKey);
+};
+export const designType = _decorator.type;
+export const editorOnly = (...args) => {
+    _decorator.property({ serializable: true, editorOnly: true })(...args);
+};
+export const idem = (_, propertyKey, descriptor) => {
+    const set = descriptor.set;
+    descriptor.set = function (value) {
+        // @ts-expect-error Dynamic property access by the decorated key.
+        if (this[propertyKey] === value) {
+            return;
+        }
+        // @ts-expect-error Setter type is preserved by the original descriptor.
+        set.call(this, value);
+    };
+};
+export function idemBy(equals) {
+    return (_target, propertyKey, descriptor) => {
+        const set = descriptor.set;
+        descriptor.set = function (value) {
+            // @ts-expect-error Dynamic property access by the decorated key.
+            if (equals(this[propertyKey], value)) {
+                return;
+            }
+            // @ts-expect-error Setter type is preserved by the original descriptor.
+            set.call(this, value);
+        };
+    };
+}
+//# sourceMappingURL=legacy-general-decorator.js.map

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

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

package/lib/decorator/legacy/utils.js

@@ -0,0 +1,17 @@
+export function defineShortenPropertyDecorator(decorator, ...defaultArgs) {
+    return ((...args) => {
+        if (args.length === 0) {
+            // @x()
+            return decorator(...defaultArgs);
+        }
+        else if (!(typeof args[0] === 'object' && args[0] && typeof args[1] === 'string' || typeof args[1] === 'symbol')) {
+            // @x(opts)
+            return decorator(...args);
+        }
+        else {
+            // @x
+            return decorator(...defaultArgs)(...args);
+        }
+    });
+}
+//# sourceMappingURL=utils.js.map

package/lib/export/2d.d.ts

@@ -0,0 +1,2 @@
+export { Transform2DComponent, TransformChangeFlagsObserver, TransformFlag } from '../2d/transform-2d-component.ts';
+//# sourceMappingURL=2d.d.ts.map

package/lib/export/2d.js

@@ -0,0 +1,2 @@
+export { Transform2DComponent, TransformChangeFlagsObserver, TransformFlag } from "../2d/transform-2d-component.js";
+//# sourceMappingURL=2d.js.map