@opencode/codemode 0.0.0-dev-20043 → 0.0.0-dev-20048

package/dist/stdlib/array.d.ts

@@ -1,5 +1,11 @@
 import { Effect } from "effect";
-import { type Value } from "../interpreter/objects.js";
+import { type Method } from "../interpreter/native.js";
+import { Obj, type Value } from "../interpreter/objects.js";
 import type { Interpreter } from "../interpreter/interpreter.js";
 export declare const sortArray: <R>(ctx: Interpreter<R>, target: Array<Value>, comparator: Value, name: string) => Effect.Effect<Array<Value>, unknown, R>;
 export declare const arrayGlobal: <R>(ctx: Interpreter<R>) => import("../interpreter/objects.js").Native<R>;
+/**
+ * The callback methods Array and Uint8Array share. They fix the iteration length while reading existing elements
+ * live; `wrap` builds the collection `map` and `filter` return.
+ */
+export declare const callbackMethods: <R, T extends Obj>(ctx: Interpreter<R>, label: string, self: (thisValue: Value, name: string) => T, elements: (target: T) => ArrayLike<Value>, wrap: (values: Array<Value>) => Value) => Array<Method>;

package/dist/stdlib/array.js

@@ -103,15 +103,6 @@ export const arrayGlobal = (ctx) => {
     ]);
     const self = (thisValue, name) => receiver(Arr, thisValue, `Array.prototype.${name}`);
     const optNumber = (value) => (value === undefined ? undefined : coerceToInteger(value));
-    // Callback methods fix the iteration length while reading existing elements live.
-    const iterate = (name, length, body) => [
-        name,
-        length,
-        (thisValue, args) => {
-            const target = self(thisValue, name);
-            return body(target.items, target, applyCollectionCallback(ctx, args[0], `Array.${name}`), args);
-        },
-    ];
     methods(builtins, proto, [
         [
             "join",
@@ -144,7 +135,8 @@ export const arrayGlobal = (ctx) => {
             1,
             (thisValue, args) => {
                 const target = self(thisValue, "lastIndexOf").items;
-                return args[1] === undefined ? target.lastIndexOf(args[0]) : target.lastIndexOf(args[0], optNumber(args[1]));
+                // An explicit undefined is a fromIndex of 0, unlike omitting it.
+                return args.length < 2 ? target.lastIndexOf(args[0]) : target.lastIndexOf(args[0], optNumber(args[1]));
             },
         ],
         ["at", 1, (thisValue, args) => self(thisValue, "at").items.at(optNumber(args[0]) ?? 0)],
@@ -311,6 +303,47 @@ export const arrayGlobal = (ctx) => {
                 .items.entries()
                 .map(([index, item]) => wrap([index, item]))),
         ],
+        [
+            "flatMap",
+            1,
+            (thisValue, args) => {
+                const target = self(thisValue, "flatMap");
+                const apply = applyCollectionCallback(ctx, args[0], "Array.flatMap");
+                return Effect.gen(function* () {
+                    const length = target.items.length;
+                    const values = [];
+                    for (let index = 0; index < length; index += 1) {
+                        if (!(index in target.items))
+                            continue;
+                        const mapped = yield* apply([target.items[index], index, target]);
+                        if (mapped instanceof Arr)
+                            values.push(...mapped.items);
+                        else
+                            values.push(mapped);
+                    }
+                    return wrap(values);
+                });
+            },
+        ],
+        ...callbackMethods(ctx, "Array", self, (target) => target.items, wrap),
+    ]);
+    define(proto, IteratorSymbol, get(proto, "values"), hidden);
+    return array;
+};
+/**
+ * The callback methods Array and Uint8Array share. They fix the iteration length while reading existing elements
+ * live; `wrap` builds the collection `map` and `filter` return.
+ */
+export const callbackMethods = (ctx, label, self, elements, wrap) => {
+    const iterate = (name, length, body) => [
+        name,
+        length,
+        (thisValue, args) => {
+            const target = self(thisValue, name);
+            return body(elements(target), target, applyCollectionCallback(ctx, args[0], `${label}.${name}`), args);
+        },
+    ];
+    return [
         iterate("map", 1, (target, receiver, apply) => Effect.gen(function* () {
             const length = target.length;
             const values = [];
@@ -322,20 +355,6 @@ export const arrayGlobal = (ctx) => {
             }
             return wrap(values);
         })),
-        iterate("flatMap", 1, (target, receiver, apply) => Effect.gen(function* () {
-            const length = target.length;
-            const values = [];
-            for (let index = 0; index < length; index += 1) {
-                if (!(index in target))
-                    continue;
-                const mapped = yield* apply([target[index], index, receiver]);
-                if (mapped instanceof Arr)
-                    values.push(...mapped.items);
-                else
-                    values.push(mapped);
-            }
-            return wrap(values);
-        })),
         iterate("filter", 1, (target, receiver, apply) => Effect.gen(function* () {
             const length = target.length;
             const values = [];
@@ -416,7 +435,7 @@ export const arrayGlobal = (ctx) => {
                 while (start < length && !(start in target))
                     start += 1;
                 if (start === length) {
-                    throw typeError("Array.reduce of an empty array with no initial value.");
+                    throw typeError(`${label}.reduce of an empty array with no initial value.`);
                 }
                 accumulator = target[start];
                 start += 1;
@@ -435,7 +454,7 @@ export const arrayGlobal = (ctx) => {
                 while (start >= 0 && !(start in target))
                     start -= 1;
                 if (start < 0) {
-                    throw typeError("Array.reduceRight of an empty array with no initial value.");
+                    throw typeError(`${label}.reduceRight of an empty array with no initial value.`);
                 }
                 accumulator = target[start];
                 start -= 1;
@@ -447,7 +466,5 @@ export const arrayGlobal = (ctx) => {
             }
             return accumulator;
         })),
-    ]);
-    define(proto, IteratorSymbol, get(proto, "values"), hidden);
-    return array;
+    ];
 };

package/dist/stdlib/bytes.js

@@ -4,6 +4,7 @@ import { constructor, methods, prototypeFrom, receiver, requiresNew } from "../i
 import { IteratorSymbol, rangeError, syntaxError, typeError } from "../interpreter/model.js";
 import { define, defineAccessor, get, hidden, Arr, Bytes, hostIterator, Obj, coerceToInteger, coerceToNumber, coerceToString, } from "../interpreter/objects.js";
 import { describeValue } from "../interpreter/references.js";
+import { callbackMethods, sortArray } from "./array.js";
 /** The bytes a Uint8Array, array, or other iterable of numbers describes; the host array clamps each value. */
 const collectBytes = (ctx, source, name) => {
     if (source instanceof Bytes)
@@ -110,6 +111,22 @@ export const uint8ArrayGlobal = (ctx) => {
                 return target;
             },
         ],
+        [
+            "sort",
+            1,
+            (thisValue, args) => {
+                const target = self(thisValue, "sort");
+                // Without a comparator, typed arrays sort numerically rather than by string.
+                if (args[0] === undefined) {
+                    target.bytes.sort();
+                    return target;
+                }
+                return Effect.map(sortArray(ctx, [...target.bytes], args[0], "Uint8Array.sort"), (sorted) => {
+                    target.bytes.set(Uint8Array.from(sorted, coerceToNumber));
+                    return target;
+                });
+            },
+        ],
         [
             "indexOf",
             1,
@@ -120,7 +137,7 @@ export const uint8ArrayGlobal = (ctx) => {
             1,
             (thisValue, args) => {
                 const target = self(thisValue, "lastIndexOf").bytes;
-                return args[1] === undefined
+                return args.length < 2
                     ? target.lastIndexOf(coerceToNumber(args[0]))
                     : target.lastIndexOf(coerceToNumber(args[0]), optNumber(args[1]));
             },
@@ -151,6 +168,7 @@ export const uint8ArrayGlobal = (ctx) => {
                 .bytes.entries()
                 .map(([index, byte]) => wrapAll([index, byte]))),
         ],
+        ...callbackMethods(ctx, "Uint8Array", self, (target) => target.bytes, (values) => wrap(Uint8Array.from(values, coerceToNumber))),
     ]);
     define(proto, IteratorSymbol, get(proto, "values"), hidden);
     return uint8Array;

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode/codemode",
-  "version": "0.0.0-dev-20043",
+  "version": "0.0.0-dev-20048",
   "description": "Effect-native confined code execution over schema-described tools",
   "type": "module",
   "license": "MIT",