getPropNames -> getOwnPropertyNames

Author: justjake

packages/quickjs-emscripten-core/src/context.ts

@@ -18,7 +18,12 @@ import type { JSPromiseState } from "./deferred-promise"
 import { QuickJSDeferredPromise } from "./deferred-promise"
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 import type { shouldInterruptAfterDeadline } from "./interrupt-helpers"
-import { QuickJSNotImplemented, QuickJSPromisePending, QuickJSUnwrapError } from "./errors"
+import {
+  QuickJSEmptyGetOwnPropertyNames,
+  QuickJSNotImplemented,
+  QuickJSPromisePending,
+  QuickJSUnwrapError,
+} from "./errors"
 import type { Disposable, DisposableArray, DisposableFail, DisposableSuccess } from "./lifetime"
 import {
   DisposableResult,
@@ -865,13 +870,16 @@ export class QuickJSContext
    * `Object.getOwnPropertyNames(handle)`.
    * Similar to the [standard semantics](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyNames).
    */
-  getPropNames(
+  getOwnPropertyNames(
     handle: QuickJSHandle,
     options: GetOwnPropertyNamesOptions,
   ): ContextResult<DisposableArray<JSValue>> {
     this.runtime.assertOwned(handle)
     handle.value // assert alive
     const flags = getOwnPropertyNamesOptionsToFlags(options)
+    if (flags === 0) {
+      throw new QuickJSEmptyGetOwnPropertyNames("No options set, will return an empty array")
+    }
     return Scope.withScope((scope) => {
       const outPtr = scope.manage(
         this.memory.newMutablePointerArray<JSValuePointerPointerPointer>(1),
@@ -887,7 +895,6 @@ export class QuickJSContext
         return this.fail(this.memory.heapValueHandle(errorPtr))
       }
       const len = this.uint32Out.value.typedArray[0]
-      console.log("getPropNames length", len)
       const ptr = outPtr.value.typedArray[0]
       const pointerArray = new Uint32Array(this.module.HEAP8.buffer, ptr, len)
       const handles = Array.from(pointerArray).map((ptr) =>

packages/quickjs-emscripten-core/src/errors.ts

@@ -48,3 +48,7 @@ export class QuickJSUnknownIntrinsic extends TypeError {
 export class QuickJSPromisePending extends Error {
   name = "QuickJSPromisePending"
 }
+
+export class QuickJSEmptyGetOwnPropertyNames extends Error {
+  name = "QuickJSEmptyGetOwnPropertyNames"
+}

packages/quickjs-emscripten-core/src/types.ts

@@ -41,6 +41,7 @@ export type JSValueConst = Lifetime<JSValueConstPointer, JSValuePointer, QuickJS
  * You can do so from Javascript by calling the .dispose() method.
  */
 export type JSValue = Lifetime<JSValuePointer, JSValuePointer, QuickJSRuntime>
+// | Lifetime<JSValueUInt8Array, JSValueUInt8Array, QuickJSRuntime>
 
 /**
  * Wraps a C pointer to a QuickJS JSValue, which represents a Javascript value inside
@@ -285,15 +286,15 @@ export function evalOptionsToFlags(evalOptions: ContextEvalOptions | number | un
 
 export interface GetOwnPropertyNamesOptions {
   /** Include number properties like array indexes *as numbers* in the result. This is not standards-compliant */
-  includeNumbers?: boolean
+  numbers?: boolean
   /** Enable standards-compliant number properties. When set, `includeNumbers` is ignored. */
   numbersAsStrings?: boolean
   /** Include strings in the result */
-  includeStrings?: boolean
+  strings?: boolean
   /** Include symbols in the result */
-  includeSymbols?: boolean
-  /** Include private properties in the result */
-  includePrivate?: boolean
+  symbols?: boolean
+  /** Include implementation-specific private properties in the result */
+  quickjsPrivate?: boolean
   /** Only include the enumerable properties */
   onlyEnumerable?: boolean
 }
@@ -311,11 +312,11 @@ export function getOwnPropertyNamesOptionsToFlags(
   }
 
   const {
-    includeStrings,
-    includeSymbols,
-    includePrivate,
+    strings: includeStrings,
+    symbols: includeSymbols,
+    quickjsPrivate: includePrivate,
     onlyEnumerable,
-    includeNumbers,
+    numbers: includeNumbers,
     numbersAsStrings,
   } = options
   let flags = 0

packages/quickjs-emscripten/src/quickjs.test.ts

@@ -408,7 +408,7 @@ function contextTests(getContext: GetTestContext, isDebug = false) {
     })
   })
 
-  describe("getPropNames", () => {
+  describe("getOwnPropertyNames", () => {
     it("gets array indexes as *numbers*", ({ manage }) => {
       const array = manage(vm.newArray())
       vm.setProp(array, 0, vm.undefined)
@@ -417,8 +417,8 @@ function contextTests(getContext: GetTestContext, isDebug = false) {
 
       const props = manage(
         vm
-          .getPropNames(array, {
-            includeNumbers: true,
+          .getOwnPropertyNames(array, {
+            numbers: true,
           })
           .unwrap(),
       )
@@ -440,12 +440,12 @@ function contextTests(getContext: GetTestContext, isDebug = false) {
       vm.setProp(obj, sym, vm.undefined)
 
       const props = manage(
-        vm.unwrapResult(
-          vm.getPropNames(obj, {
+        vm
+          .getOwnPropertyNames(obj, {
             onlyEnumerable: true,
-            includeStrings: true,
-          }),
-        ),
+            strings: true,
+          })
+          .unwrap(),
       )
 
       assert.strictEqual(props.length, 3)
@@ -463,16 +463,35 @@ function contextTests(getContext: GetTestContext, isDebug = false) {
 
       const props = manage(
         vm.unwrapResult(
-          vm.getPropNames(obj, {
+          vm.getOwnPropertyNames(obj, {
             onlyEnumerable: true,
-            includeSymbols: true,
+            symbols: true,
           }),
         ),
       )
 
       assert.strictEqual(props.length, 1)
       assert.strictEqual(vm.typeof(props[0]), "symbol")
     })
+
+    it("gets number keys as strings when in standard compliant mode", ({ manage }) => {
+      const array = manage(vm.newArray())
+      vm.setProp(array, 0, vm.undefined)
+      vm.setProp(array, 1, vm.undefined)
+      vm.setProp(array, 2, vm.undefined)
+      vm.setProp(array, "dog", vm.undefined)
+      const props = manage(
+        vm.getOwnPropertyNames(array, {
+          strings: true,
+          numbersAsStrings: true,
+          onlyEnumerable: true,
+        }),
+      )
+        .unwrap()
+        .map((p) => vm.dump(p))
+
+      assert.deepStrictEqual(["0", "1", "2", "dog"], props)
+    })
   })
 
   describe(".unwrapResult", () => {