[v3.8.6] Mark some properties as @dontmangle.

cocos/core/curves/keyframe-curve.ts

@@ -222,7 +222,7 @@
         if (values !== undefined) {
             assertIsTrue(Array.isArray(times));
             this.setKeyframes(
                 times.slice(),
                 values.slice(),
             );
         } else {
@@ -280,9 +280,18 @@
         return iNext;
     }
 
-    // Times are always sorted and 1-1 correspond to values.
+    /**
+     * Times are always sorted and 1-1 correspond to values.
+     * @dontmangle
+     * NOTE: _times is a serializable property set by `CCClass.fastDefine`,
+     * so it should not be mangled while `mangleProtected` is true in `<<ProjectRoot>>/engine-mangle-config.json`.
+     */
     protected _times: number[] = [];
-
+    /**
+     * @dontmangle
+     * NOTE: _values is a serializable property set by `CCClass.fastDefine`,
+     * so it should not be mangled while `mangleProtected` is true in `<<ProjectRoot>>/engine-mangle-config.json`.
+     */
     protected _values: TKeyframeValue[] = [];
 }
 

cocos/core/data/object.ts

@@ -196,6 +196,12 @@
      * @internal
      */
     public _objFlags: number = 0;
+
+    /**
+     * @dontmangle
+     * NOTE: _name is a serializable property set by `CCClass.fastDefine`,
+     * so it should not be mangled while `mangleProtected` is true in `<<ProjectRoot>>/engine-mangle-config.json`.
+     */
     protected declare _name: string;
 
     constructor (name = '') {
@@ -384,7 +390,7 @@
 
 const prototype = CCObject.prototype;
 if (EDITOR || TEST) {
     js.get(prototype, 'isRealValid', function (this: CCObject) {
         return !(this._objFlags & RealDestroyed);
     });
 
@@ -396,10 +402,10 @@
     js.getset(
         prototype,
         'objFlags',
         function (this: CCObject) {
             return this._objFlags;
         },
         function (this: CCObject, objFlags: CCObject.Flags) {
             this._objFlags = objFlags;
         },
     );
@@ -416,7 +422,7 @@
     * TODO: this is a dynamic inject method, should be define in class
     * issue: https://github.com/cocos/cocos-engine/issues/14643
     */
     (prototype as any).realDestroyInEditor = function (): void {
         if (!(this._objFlags & Destroyed)) {
             warnID(5001);
             return;

cocos/core/event/eventify.ts

@@ -151,6 +151,13 @@ export interface IEventified {
  */
 export function Eventify<TBase> (base: Constructor<TBase>): Constructor<TBase & IEventified> {
     class Eventified extends (base as unknown as any) {
+        /**
+         * @dontmangle
+         * NOTE: Eventified mixins all properties from CallbacksInvoker.prototype in the following code.
+         * After invoking `Eventify` for a class, CallbacksInvoker's constructor will not be called,
+         * but its functions may invoke `this._callbackTable` which is declared as `public` in CallbacksInvoker.
+         * Marking it as dontmangle is a workaround to avoid the issue that `this._callbackTable` is not defined.
+         */
         protected _callbackTable = createMap(true);
 
         public once<Callback extends (...any) => void> (type: EventType, callback: Callback, target?: any): Callback {

cocos/core/geometry/curve.ts

@@ -102,6 +102,11 @@
  * 描述一条曲线，其中每个相邻关键帧采用三次hermite插值计算。
  */
 export class AnimationCurve {
+    /**
+     * @dontmangle
+     * NOTE: _curve is a serializable property set by `CCClass.fastDefine`,
+     * so it should not be mangled while `mangleProtected` is true in `<<ProjectRoot>>/engine-mangle-config.json`.
+     */
     private _curve!: RealCurve;
 
     private static defaultKF: Keyframe[] = [{
@@ -336,7 +341,7 @@
         let mid;
         while (right - left > 1) {
             mid = Math.floor((left + right) / 2);
             if (curve.getKeyframeTime(mid) >= t) {
                 right = mid;
             } else {
                 left = mid;

cocos/scene-graph/node-dev.ts

@@ -34,7 +34,7 @@
 
 export function nodePolyfill (Node): void {
     if ((EDITOR && !IS_PREVIEW) || TEST) {
         Node.prototype._onPreDestroy = function (): boolean {
             const destroyByParent: boolean = this._onPreDestroyBase();
             if (!destroyByParent) {
                 // ensure this node can reattach to scene by undo system
@@ -46,13 +46,13 @@
     }
 
     if (EDITOR || TEST) {
         Node.prototype._checkMultipleComp = function (ctor): boolean {
             const existing = this.getComponent(ctor._disallowMultiple);
             if (existing) {
                 if (existing.constructor === ctor) {
-                    throw Error(getError(3805, js.getClassName(ctor), this._name));
+                    throw Error(getError(3805, js.getClassName(ctor), this._name as string));
                 } else {
-                    throw Error(getError(3806, js.getClassName(ctor), this._name, js.getClassName(existing)));
+                    throw Error(getError(3806, js.getClassName(ctor), this._name as string, js.getClassName(existing)));
                 }
             }
             return true;
@@ -62,12 +62,12 @@
          * @param {Component} depended
          * @return {Component[]}
          */
         Node.prototype._getDependComponent = function (depended): Component[] {
             const dependant: Component[] = [];
             for (let i = 0; i < this._components.length; i++) {
-                const comp = this._components[i];
+                const comp: Component = this._components[i];
                 if (comp !== depended && comp.isValid && !legacyCC.Object._willDestroy(comp)) {
-                    const reqComps = comp.constructor._requireComponent;
+                    const reqComps = (comp.constructor as typeof Component)._requireComponent;
                     if (reqComps) {
                         if (Array.isArray(reqComps)) {
                             for (let i = 0; i < reqComps.length; i++) {
@@ -89,7 +89,7 @@
          * @param {Component} comp
          * @param {Number} index
          */
-        Node.prototype._addComponentAt = function (comp, index): void {
+        Node.prototype._addComponentAt = function (comp: Component, index: number): void {
             if (this._objFlags & Destroying) {
                 return error('isDestroying');
             }
@@ -101,7 +101,7 @@
             }
 
             // recheck attributes because script may changed
-            const ctor = comp.constructor;
+            const ctor = comp.constructor as any;
             if (ctor._disallowMultiple) {
                 if (!this._checkMultipleComp(ctor)) {
                     return undefined;
@@ -125,7 +125,7 @@
             comp.node = this;
             this._components.splice(index, 0, comp);
             if (EDITOR && !IS_PREVIEW && EditorExtends.Node && EditorExtends.Component) {
-                const node = EditorExtends.Node.getNode(this._id);
+                const node = EditorExtends.Node.getNode(this._id as string);
                 if (node) {
                     EditorExtends.Component.add(comp._id, comp);
                 }
@@ -136,7 +136,7 @@
             return undefined;
         };
 
         Node.prototype.onRestore = function (): void {
             // check activity state
             const shouldActiveNow = this._active && !!(this._parent && this._parent._activeInHierarchy);
             if (this._activeInHierarchy !== shouldActiveNow) {
@@ -145,34 +145,37 @@
         };
         Node.prototype._onRestoreBase = Node.prototype.onRestore;
 
         Node.prototype._registerIfAttached = function (register): void {
             if (!this._id) {
+                // eslint-disable-next-line no-console
                 console.warn(`Node(${this && this.name}}) is invalid or its data is corrupted.`);
                 return;
             }
             if (EditorExtends.Node && EditorExtends.Component) {
                 if (register) {
-                    EditorExtends.Node.add(this._id, this);
+                    EditorExtends.Node.add(this._id as string, this);
 
                     for (let i = 0; i < this._components.length; i++) {
                         const comp = this._components[i];
                         if (!comp || !comp._id) {
+                            // eslint-disable-next-line no-console
                             console.warn(`Component attached to node:${this.name} is corrupted`);
                         } else {
-                            EditorExtends.Component.add(comp._id, comp);
+                            EditorExtends.Component.add(comp._id as string, comp);
                         }
                     }
                 } else {
                     for (let i = 0; i < this._components.length; i++) {
                         const comp = this._components[i];
                         if (!comp || !comp._id) {
+                            // eslint-disable-next-line no-console
                             console.warn(`Component attached to node:${this.name} is corrupted`);
                         } else {
-                            EditorExtends.Component.remove(comp._id);
+                            EditorExtends.Component.remove(comp._id as string);
                         }
                     }
 
-                    EditorExtends.Node.remove(this._id);
+                    EditorExtends.Node.remove(this._id as string);
                 }
             }
 
@@ -186,7 +189,7 @@
 
     if (DEV) {
         // promote debug info
-        js.get(Node.prototype, ' INFO ', function (this: any) {
+        js.get(Node.prototype as Record<string, any>, ' INFO ', function (this: any) {
             let path = '';
             // eslint-disable-next-line @typescript-eslint/no-this-alias
             let node: any = this;

cocos/scene-graph/node.ts

@@ -1331,6 +1331,14 @@ export class Node extends CCObject implements ISchedulable, CustomSerializable {
         this.emit(NodeEventType.CHILDREN_ORDER_CHANGED);
     }
 
+    /**
+     * @dontmangle
+     * NOTE: the protected method `_instantiate` is invoked by dynamically without type information.
+     * See `instantiate` in cocos/serialization/instantiate.ts.
+     * ```ts
+     * clone = original._instantiate(null, true); // original is any, so _instantiate should not be mangled.
+     * ```
+     */
     protected _instantiate (cloned?: Node | null, isSyncedNode: boolean = false): Node {
         if (!cloned) {
             cloned = cclegacy.instantiate._clone(this, this) as Node;

cocos/scene-graph/prefab/prefab.ts

@@ -157,6 +157,14 @@ export class Prefab extends Asset {
         return this._createFunction!(rootToRedirect);  // this.data._instantiate();
     }
 
+    /**
+     * @dontmangle
+     * NOTE: the protected method `_instantiate` is invoked by dynamically without type information.
+     * See `instantiate` in cocos/serialization/instantiate.ts.
+     * ```ts
+     * clone = original._instantiate(null, true); // original is any, so _instantiate should not be mangled.
+     * ```
+     */
     protected _instantiate (): Node {
         let node: Node;
         let useJit = false;