polyfill: sort string keys, equality fix

Author: acutmore

README.md

@@ -137,13 +137,6 @@ c.d === d; // true
 Object.is(c.zero, -0); // true
 ```
 
-The key order matches the argument used to construct it ([#1](https://github.com/acutmore/proposal-composites/issues/1)).
-
-```js
-const c = Composite({ z: true, x: true, y: true });
-Object.keys(c); // ["z", "x", "y"]
-```
-
 ### What are the equality semantics?
 
 Two composites are equal only if they have the same prototype ([#5](https://github.com/acutmore/proposal-composites/issues/5)) and their properties form the same set of key-value pairs.

polyfill/composite.test.ts

@@ -51,7 +51,7 @@ await test("key order", () => {
         [s3]: 0,
     });
     const keys = Reflect.ownKeys(c);
-    assert.deepStrictEqual(keys, ["0", "10", "b", "a", s1, sB, s2, sA, s3]);
+    assert.deepStrictEqual(keys, ["0", "10", "a", "b", s1, sB, s2, sA, s3]);
 });
 await test(".equal non-composite equal", () => {
     assert(Composite.equal(-0, 0));
@@ -82,7 +82,12 @@ await test(".equal composites symbol props equal", () => {
     const s2 = Symbol();
     const c1 = Composite({ [s1]: 1, [s2]: 2 });
     assert(Composite.equal(c1, Composite({ [s1]: 1, [s2]: 2 })));
-    assert(Composite.equal(c1, Composite({ [s2]: 2, [s1]: 1 })));
+
+    const c2 = Composite({ [s2]: 2, [s1]: 1 });
+    assert(Composite.equal(c1, c2));
+
+    assert.deepStrictEqual(Reflect.ownKeys(c1), [s1, s2]);
+    assert.deepStrictEqual(Reflect.ownKeys(c2), [s2, s1]);
 });
 await test(".equal composites symbol props not-equal", () => {
     const s1 = Symbol();
@@ -142,3 +147,19 @@ await test(".equal composites interesting decimal numbers", () => {
     assert(c2 !== c3, "c2 and c3 should not be the same object");
     assert(Composite.equal(c2, c3), "c2 and c3 should be equal");
 });
+await test(".equal composites with polluted Object.prototype", () => {
+    (Object.prototype as any)["pollution"] = true;
+    try {
+        const c1 = Composite({ pollution: true });
+        const c2 = Composite({ other: true });
+        assert(!Composite.equal(c1, c2), "c1 and c2 should not be equal");
+    } finally {
+        delete (Object.prototype as any)["pollution"];
+    }
+});
+
+await test(".equal composites with different key order", () => {
+    const c1 = Composite({ a: true, b: true });
+    const c2 = Composite({ b: true, a: true });
+    assert(Composite.equal(c1, c2), "c1 and c2 should not be equal");
+});

polyfill/composite.ts

@@ -1,5 +1,15 @@
-import { assert, sameValueZero } from "./internal/utils.ts";
-import { ownKeys, apply, freeze, setAdd, setHas, Set, setPrototypeOf, objectPrototype } from "./internal/originals.ts";
+import { assert, EMPTY, sameValueZero } from "./internal/utils.ts";
+import {
+    ownKeys,
+    apply,
+    freeze,
+    setAdd,
+    setHas,
+    Set,
+    setPrototypeOf,
+    objectPrototype,
+    sort,
+} from "./internal/originals.ts";
 import { __Composite__, objectIsComposite, maybeGetCompositeHash, setHash } from "./internal/composite-class.ts";
 
 export type Composite = __Composite__;
@@ -13,8 +23,19 @@ export function Composite(arg: object): Composite {
     }
     const argKeys = ownKeys(arg);
     const c = new __Composite__();
+    const stringKeys: string[] = [];
     for (let i = 0; i < argKeys.length; i++) {
         let k = argKeys[i];
+        if (typeof k === "string") {
+            stringKeys[stringKeys.length] = k;
+        } else {
+            DEV: assert(typeof k === "symbol");
+            (c as any)[k] = (arg as any)[k];
+        }
+    }
+    apply(sort, stringKeys, EMPTY);
+    for (let i = 0; i < stringKeys.length; i++) {
+        let k = stringKeys[i];
         (c as any)[k] = (arg as any)[k];
     }
     setPrototypeOf(c, objectPrototype);
@@ -55,6 +76,7 @@ export function compositeEqual(a: unknown, b: unknown): boolean {
         const aKey = aKeys[i];
         const bKey = bKeys[i];
         if (typeof aKey !== typeof bKey) {
+            // Different ratios of strings and symbols
             return false;
         }
         if (typeof aKey === "symbol") {