@microsoft/fast-html 1.0.0-alpha.42 → 1.0.0-alpha.44

package/dist/esm/components/observer-map.spec.js

@@ -1,6 +1,6 @@
 import { expect, test } from "@playwright/test";
 import { ObserverMap } from "./observer-map.js";
-import { Schema, defsPropertyName } from "./schema.js";
+import { defsPropertyName, Schema } from "./schema.js";
 const testElementName = "test-class";
 test.describe("ObserverMap", async () => {
     let observerMap;

package/dist/esm/components/utilities.js

@@ -761,20 +761,27 @@ function getSchemaProperties(schema) {
  * @returns The array with observable properties and change notifications
  */
 function assignObservablesToArray(proxiedData, schema, rootSchema, target, rootProperty) {
-    const data = proxiedData.map((item) => {
-        const originalItem = Object.assign({}, item);
-        assignProxyToItemsInArray(item, originalItem, schema, rootSchema);
-        return Object.assign(item, originalItem);
-    });
+    const schemaProperties = getSchemaProperties(schema);
+    // If the schema has no properties, the array contains primitives (e.g. string[])
+    // — observe the array for changes but skip per-item proxying.
+    const data = schemaProperties
+        ? proxiedData.map((item) => {
+            const originalItem = Object.assign({}, item);
+            assignProxyToItemsInArray(item, originalItem, schema, rootSchema);
+            return Object.assign(item, originalItem);
+        })
+        : proxiedData;
     Observable.getNotifier(data).subscribe({
         handleChange(subject, args) {
             args.forEach((arg) => {
                 if (arg.addedCount > 0) {
-                    for (let i = arg.addedCount - 1; i >= 0; i--) {
-                        const item = subject[arg.index + i];
-                        const originalItem = Object.assign({}, item);
-                        assignProxyToItemsInArray(item, originalItem, schema, rootSchema);
-                        Object.assign(item, originalItem);
+                    if (schemaProperties) {
+                        for (let i = arg.addedCount - 1; i >= 0; i--) {
+                            const item = subject[arg.index + i];
+                            const originalItem = Object.assign({}, item);
+                            assignProxyToItemsInArray(item, originalItem, schema, rootSchema);
+                            Object.assign(item, originalItem);
+                        }
                     }
                     // Notify observers of the target object's root property
                     Observable.notify(target, rootProperty);
@@ -782,7 +789,29 @@ function assignObservablesToArray(proxiedData, schema, rootSchema, target, rootP
             });
         },
     });
-    return data;
+    if (schemaProperties !== null) {
+        return data;
+    }
+    // For primitive arrays, wrap in a Proxy so that direct index assignment
+    // (e.g. arr[0] = value) triggers FAST's splice-based change tracking and
+    // keeps repeat directives in sync. Object arrays are not wrapped because
+    // their items are individually proxied, and FAST's own push/splice/etc.
+    // already carry splice records — double-wrapping would produce duplicate
+    // splice notifications.
+    return new Proxy(data, {
+        set: (arr, prop, value) => {
+            const idx = typeof prop === "string" ? Number(prop) : NaN;
+            if (typeof prop !== "symbol" && Number.isInteger(idx) && idx >= 0) {
+                // splice() replaces the item in-place and creates the splice
+                // record that FAST's ArrayObserver delivers to repeat directives.
+                Array.prototype.splice.call(arr, idx, 1, value);
+            }
+            else {
+                arr[prop] = value;
+            }
+            return true;
+        },
+    });
 }
 /**
  * Extracts the definition name from a JSON Schema $ref property
@@ -859,6 +888,12 @@ export function assignObservables(schema, rootSchema, data, target, rootProperty
                     }));
                 }
             }
+            else {
+                // Primitive array (items have no schema $ref): wrap in a proxy so that
+                // direct index assignments (e.g. arr[0] = value) use FAST's splice-based
+                // change tracking and keep repeat directives in sync.
+                proxiedData = assignObservablesToArray(proxiedData, schema, rootSchema, target, rootProperty);
+            }
             break;
         }
         case "object": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@microsoft/fast-html",
-  "version": "1.0.0-alpha.42",
+  "version": "1.0.0-alpha.44",
   "type": "module",
   "author": {
     "name": "Microsoft",