@colyseus/schema 5.0.2 → 5.0.4

package/build/input/index.mjs

@@ -1237,11 +1237,24 @@ function checkInheritedFlags(tree, parent, parentIndex) {
         const refType = Metadata.isValidInstance(tree.ref)
             ? tree.ref.constructor
             : tree.ref[$childType];
+        // #218: nested Schema fields inherit visibility from a @view-gated
+        // parent regardless of whether the parent is a collection. The
+        // `parentIsCollection` constraint that used to live here blocked
+        // nested-Schema-field-of-@view-tagged-Schema from sharing visibility,
+        // forcing users to wrap the child in an ArraySchema as a workaround.
+        //
+        // #226 (4.0.25): items inside a non-default-tag `@view(N)` collection
+        // also inherit visibility from the parent collection, so items
+        // pushed/set after `view.add(state, N)` show up automatically.
+        // Default-tag `@view()` collections keep per-item gating —
+        // `view.add(item)` is still required to opt each one in.
+        // The `parentMetadata[parentIndex].tag` access is safe inside the
+        // `fieldHasViewTag` short-circuit (the metadata entry and its `tag`
+        // are guaranteed to exist when that flag is set).
         tree.isVisibilitySharedWithParent = (parentChangeTree.isFiltered
             && typeof refType !== "string"
-            && !fieldHasViewTag
             && !fieldHasStream
-            && parentIsCollection);
+            && (!fieldHasViewTag || (parentIsCollection && parentMetadata[parentIndex].tag !== DEFAULT_VIEW_TAG)));
     }
 }
 
@@ -5554,6 +5567,33 @@ const Metadata = {
     getStreamPriority(metadata, index) {
         return metadata?.[$streamPriorities]?.[index];
     },
+    /**
+     * Install a single field with full encoder wiring: accessor descriptor
+     * on the prototype + `metadata[$encoders]` slot for primitives. Shared
+     * between `Metadata.setFields` (build path) and
+     * `Reflection.makeEncodable` (Reflection upgrade path).
+     */
+    defineField(target, metadata, fieldIndex, fieldName, type) {
+        const normalized = getNormalizedType(type);
+        const { complexTypeKlass, childType } = resolveFieldType(normalized);
+        Metadata.addField(metadata, fieldIndex, fieldName, normalized, getPropertyDescriptor(fieldName, fieldIndex, childType, complexTypeKlass));
+        // Install accessor descriptor on the prototype (once per class field).
+        if (metadata[$descriptors][fieldName]) {
+            Object.defineProperty(target.prototype, fieldName, metadata[$descriptors][fieldName]);
+        }
+        // Pre-compute encoder function for primitive types.
+        if (typeof normalized === "string") {
+            if (!metadata[$encoders]) {
+                Object.defineProperty(metadata, $encoders, {
+                    value: [],
+                    enumerable: false,
+                    configurable: true,
+                    writable: true,
+                });
+            }
+            metadata[$encoders][fieldIndex] = encode[normalized];
+        }
+    },
     setFields(target, fields) {
         // for inheritance support
         const constructor = target.prototype.constructor;
@@ -5591,17 +5631,7 @@ const Metadata = {
             });
         }
         for (const field in fields) {
-            const type = getNormalizedType(fields[field]);
-            const { complexTypeKlass, childType } = resolveFieldType(type);
-            Metadata.addField(metadata, fieldIndex, field, type, getPropertyDescriptor(field, fieldIndex, childType, complexTypeKlass));
-            // Install accessor descriptor on the prototype (once per class field).
-            if (metadata[$descriptors][field]) {
-                Object.defineProperty(target.prototype, field, metadata[$descriptors][field]);
-            }
-            // Pre-compute encoder function for primitive types.
-            if (typeof type === "string") {
-                metadata[$encoders][fieldIndex] = encode[type];
-            }
+            Metadata.defineField(constructor, metadata, fieldIndex, field, fields[field]);
             fieldIndex++;
         }
         return target;
@@ -6584,8 +6614,19 @@ class Encoder {
         // selected element is passed to `view.add()` which populates
         // view.changes with the stream-link ADD + element-field ADDs.
         this._emitStreamPriority(view);
-        // encode visibility-triggered changes collected by view.add()
-        for (const [refId, changes] of view.changes) {
+        //
+        // `view.changes` Map insertion order IS topological order:
+        //   - `view.add` walks the parent chain to root via `addParentOf`
+        //     (depth-first ancestor-first), inserting every ancestor's
+        //     entry before the descendant's.
+        //   - `view.remove` calls `_touchAncestorsOf` before its own
+        //     write to insert any missing ancestors at the front of the
+        //     chain — empty entries that get skipped by the size==0
+        //     check below but establish Map position.
+        // No per-encode topo sort needed.
+        //
+        for (const refId of view.changes.keys()) {
+            const changes = view.changes.get(refId);
             const changeTree = this.root.changeTrees[refId];
             if (changeTree === undefined) {
                 // detached instance, remove from view and skip.