@opencode/codemode 0.0.0-dev-19566 → 0.0.0-dev-19568
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/interpreter/errors.d.ts +8 -1
- package/dist/interpreter/errors.js +50 -33
- package/dist/interpreter/execute.js +2 -2
- package/dist/interpreter/generators.js +3 -3
- package/dist/interpreter/globals.js +6 -6
- package/dist/interpreter/model.d.ts +22 -13
- package/dist/interpreter/model.js +18 -13
- package/dist/interpreter/native.d.ts +4 -5
- package/dist/interpreter/native.js +9 -8
- package/dist/interpreter/objects.d.ts +7 -5
- package/dist/interpreter/objects.js +3 -1
- package/dist/interpreter/promises.d.ts +2 -4
- package/dist/interpreter/promises.js +46 -46
- package/dist/interpreter/references.d.ts +1 -2
- package/dist/interpreter/references.js +3 -3
- package/dist/interpreter/runner.d.ts +6 -7
- package/dist/interpreter/runner.js +10 -10
- package/dist/interpreter/runtime.js +86 -79
- package/dist/interpreter/scope.js +6 -6
- package/dist/stdlib/array.d.ts +1 -2
- package/dist/stdlib/array.js +80 -84
- package/dist/stdlib/collections.js +57 -57
- package/dist/stdlib/date.js +21 -21
- package/dist/stdlib/json.js +13 -13
- package/dist/stdlib/math.js +11 -15
- package/dist/stdlib/number.js +21 -25
- package/dist/stdlib/object.d.ts +2 -2
- package/dist/stdlib/object.js +32 -36
- package/dist/stdlib/regexp.d.ts +2 -3
- package/dist/stdlib/regexp.js +15 -15
- package/dist/stdlib/string.js +69 -65
- package/dist/stdlib/url.js +55 -55
- package/dist/stdlib/value.js +4 -4
- package/dist/stdlib/web.js +4 -4
- package/package.json +1 -1
|
@@ -1,8 +1,8 @@
|
|
|
1
1
|
import { Cause, Deferred, Effect, Exit, Fiber, Scope } from "effect";
|
|
2
|
-
import {
|
|
2
|
+
import { CallSite, ProgramThrow, typeError } from "./model.js";
|
|
3
3
|
import { Callable, define, get, hidden, ProgramArray, ProgramFunction, ProgramObject, ProgramPromise, record, } from "./objects.js";
|
|
4
4
|
import { constructor, fn, methods, native, receiver, requiresNew } from "./native.js";
|
|
5
|
-
import {
|
|
5
|
+
import { createAggregateErrorValue, locate, materialize, normalizeError } from "./errors.js";
|
|
6
6
|
import { typeofValue } from "./references.js";
|
|
7
7
|
import { applyCollectionCallback, isSupportedCallback } from "./runner.js";
|
|
8
8
|
// A `resolve`/`reject` handed to an executor or thenable: calling it settles the capability.
|
|
@@ -32,10 +32,11 @@ export class PromiseRuntime {
|
|
|
32
32
|
});
|
|
33
33
|
}
|
|
34
34
|
create(effect) {
|
|
35
|
-
return Effect.
|
|
35
|
+
return Effect.flatMap(CallSite, (site) => {
|
|
36
36
|
// Allocate before forking so reruns get distinct IDs and diagnostics retain creation order.
|
|
37
37
|
const id = this.nextID++;
|
|
38
|
-
|
|
38
|
+
const body = Effect.catchDefect(effect, (defect) => Effect.die(locate(defect, site)));
|
|
39
|
+
return Effect.map(Effect.forkIn(body, this.scope, { startImmediately: true }), (fiber) => {
|
|
39
40
|
const promise = new ProgramPromise(this.proto, fiber);
|
|
40
41
|
this.active.add(promise);
|
|
41
42
|
this.ids.set(promise, id);
|
|
@@ -83,10 +84,10 @@ export class PromiseRuntime {
|
|
|
83
84
|
});
|
|
84
85
|
}
|
|
85
86
|
}
|
|
86
|
-
export const
|
|
87
|
-
|
|
88
|
-
|
|
89
|
-
|
|
87
|
+
export const resolvePromiseValue = (runner, value, own) => {
|
|
88
|
+
if (own?.promise !== undefined && value === own.promise) {
|
|
89
|
+
return Effect.die(typeError("Chaining cycle detected: a promise cannot resolve with itself."));
|
|
90
|
+
}
|
|
90
91
|
if (value instanceof ProgramPromise)
|
|
91
92
|
return runner.settlePromise(value);
|
|
92
93
|
if (!(value instanceof ProgramObject))
|
|
@@ -100,39 +101,38 @@ export const resolvePromiseValue = (runner, value, node, own) => {
|
|
|
100
101
|
const deferred = Deferred.makeUnsafe();
|
|
101
102
|
const resolve = capability(runner, "resolve", (result) => Deferred.doneUnsafe(deferred, Exit.succeed(result)));
|
|
102
103
|
const reject = capability(runner, "reject", (reason) => Deferred.doneUnsafe(deferred, Exit.fail(new ProgramThrow(reason))));
|
|
103
|
-
const executed = yield* Effect.exit(runner.invokeCallable(then, value, [resolve, reject]
|
|
104
|
+
const executed = yield* Effect.exit(runner.invokeCallable(then, value, [resolve, reject]));
|
|
104
105
|
if (!Exit.isSuccess(executed)) {
|
|
105
106
|
if (Cause.hasInterruptsOnly(executed.cause))
|
|
106
107
|
return yield* Effect.failCause(executed.cause);
|
|
107
108
|
Deferred.doneUnsafe(deferred, Exit.fail(Cause.squash(executed.cause)));
|
|
108
109
|
}
|
|
109
|
-
return yield* resolvePromiseValue(runner, yield* Deferred.await(deferred),
|
|
110
|
+
return yield* resolvePromiseValue(runner, yield* Deferred.await(deferred), own);
|
|
110
111
|
});
|
|
111
112
|
};
|
|
112
|
-
export const resolvePromise = (runner, promises, value
|
|
113
|
+
export const resolvePromise = (runner, promises, value) => {
|
|
113
114
|
if (value instanceof ProgramPromise)
|
|
114
115
|
return Effect.succeed(value);
|
|
115
|
-
return promises.createWithSelf((self) => resolvePromiseValue(runner, value,
|
|
116
|
+
return promises.createWithSelf((self) => resolvePromiseValue(runner, value, self));
|
|
116
117
|
};
|
|
117
118
|
const promiseStatics = ["all", "allSettled", "race", "any", "resolve", "reject"];
|
|
118
|
-
const invokePromiseMethod = (runner, promises, name, args
|
|
119
|
+
const invokePromiseMethod = (runner, promises, name, args) => {
|
|
119
120
|
if (name === "resolve") {
|
|
120
|
-
return resolvePromise(runner, promises, args[0]
|
|
121
|
+
return resolvePromise(runner, promises, args[0]);
|
|
121
122
|
}
|
|
122
123
|
if (name === "reject") {
|
|
123
124
|
return promises.create(Effect.fail(new ProgramThrow(args[0])));
|
|
124
125
|
}
|
|
125
126
|
return promises.create(Effect.gen(function* () {
|
|
126
|
-
const cursor = yield* runner.syncIterator(args[0]
|
|
127
|
-
if (cursor === undefined)
|
|
128
|
-
throw
|
|
129
|
-
}
|
|
127
|
+
const cursor = yield* runner.syncIterator(args[0]);
|
|
128
|
+
if (cursor === undefined)
|
|
129
|
+
throw typeError(`Promise.${name} expects an array or other synchronous iterable.`);
|
|
130
130
|
const items = [];
|
|
131
131
|
while (true) {
|
|
132
132
|
const step = yield* cursor.next;
|
|
133
133
|
if (step.done)
|
|
134
134
|
break;
|
|
135
|
-
const item = yield* resolvePromise(runner, promises, step.value
|
|
135
|
+
const item = yield* resolvePromise(runner, promises, step.value);
|
|
136
136
|
promises.markObserved(item);
|
|
137
137
|
items.push(item);
|
|
138
138
|
}
|
|
@@ -151,7 +151,7 @@ const invokePromiseMethod = (runner, promises, name, args, node) => {
|
|
|
151
151
|
return yield* Effect.failCause(exit.cause);
|
|
152
152
|
outcomes.push(record(runner.prototypes.Object, {
|
|
153
153
|
status: "rejected",
|
|
154
|
-
reason:
|
|
154
|
+
reason: materialize(runner, Cause.squash(exit.cause)),
|
|
155
155
|
}));
|
|
156
156
|
}
|
|
157
157
|
yield* Effect.yieldNow;
|
|
@@ -159,7 +159,7 @@ const invokePromiseMethod = (runner, promises, name, args, node) => {
|
|
|
159
159
|
}
|
|
160
160
|
if (name === "race") {
|
|
161
161
|
if (items.length === 0) {
|
|
162
|
-
throw
|
|
162
|
+
throw typeError("Promise.race([]) would never settle; provide at least one promise or value.");
|
|
163
163
|
}
|
|
164
164
|
return yield* settleAfterTurn(Effect.flatten(Effect.raceAll(items.map((item) => promises.await(item)))));
|
|
165
165
|
}
|
|
@@ -168,32 +168,32 @@ const invokePromiseMethod = (runner, promises, name, args, node) => {
|
|
|
168
168
|
return Effect.fail(new PromiseAnyFulfilled(exit.value));
|
|
169
169
|
if (Cause.hasInterruptsOnly(exit.cause))
|
|
170
170
|
return Effect.failCause(exit.cause);
|
|
171
|
-
return Effect.succeed(
|
|
171
|
+
return Effect.succeed(materialize(runner, Cause.squash(exit.cause)));
|
|
172
172
|
}));
|
|
173
173
|
return yield* settleAfterTurn(Effect.all(flipped, { concurrency: "unbounded" }).pipe(Effect.flatMap((reasons) => Effect.fail(new ProgramThrow(createAggregateErrorValue(runner, reasons, "All promises were rejected")))), Effect.catch((error) => error instanceof PromiseAnyFulfilled ? Effect.succeed(error.value) : Effect.fail(error))));
|
|
174
174
|
}));
|
|
175
175
|
};
|
|
176
|
-
const instanceMethod = (runner, promises, name, thisValue, args
|
|
176
|
+
const instanceMethod = (runner, promises, name, thisValue, args) => {
|
|
177
177
|
const method = `Promise.prototype.${name}`;
|
|
178
|
-
const promise = receiver(ProgramPromise, thisValue, method
|
|
178
|
+
const promise = receiver(ProgramPromise, thisValue, method);
|
|
179
179
|
promises.markObserved(promise);
|
|
180
180
|
if (name === "finally") {
|
|
181
|
-
return chainFinally(runner, promises, promise, reactionHandler(args[0], method
|
|
181
|
+
return chainFinally(runner, promises, promise, reactionHandler(args[0], method), method);
|
|
182
182
|
}
|
|
183
|
-
const onFulfilled = name === "then" ? reactionHandler(args[0], method
|
|
184
|
-
const onRejected = reactionHandler(name === "then" ? args[1] : args[0], method
|
|
185
|
-
return chainReaction(runner, promises, promise, onFulfilled, onRejected, method
|
|
183
|
+
const onFulfilled = name === "then" ? reactionHandler(args[0], method) : undefined;
|
|
184
|
+
const onRejected = reactionHandler(name === "then" ? args[1] : args[0], method);
|
|
185
|
+
return chainReaction(runner, promises, promise, onFulfilled, onRejected, method);
|
|
186
186
|
};
|
|
187
|
-
const constructPromise = (runner, promises, executor
|
|
187
|
+
const constructPromise = (runner, promises, executor) => {
|
|
188
188
|
if (!(executor instanceof ProgramFunction)) {
|
|
189
|
-
throw
|
|
189
|
+
throw typeError("new Promise(...) expects an executor function (e.g. new Promise((resolve, reject) => { ... })).");
|
|
190
190
|
}
|
|
191
191
|
return Effect.gen(function* () {
|
|
192
192
|
const deferred = Deferred.makeUnsafe();
|
|
193
|
-
const promise = yield* promises.createWithSelf((self) => Effect.flatMap(Deferred.await(deferred), (value) => resolvePromiseValue(runner, value,
|
|
193
|
+
const promise = yield* promises.createWithSelf((self) => Effect.flatMap(Deferred.await(deferred), (value) => resolvePromiseValue(runner, value, self)));
|
|
194
194
|
const resolve = capability(runner, "resolve", (value) => Deferred.doneUnsafe(deferred, Exit.succeed(value)));
|
|
195
195
|
const reject = capability(runner, "reject", (value) => Deferred.doneUnsafe(deferred, Exit.fail(new ProgramThrow(value))));
|
|
196
|
-
const executed = yield* Effect.exit(runner.invokeCallable(executor, undefined, [resolve, reject]
|
|
196
|
+
const executed = yield* Effect.exit(runner.invokeCallable(executor, undefined, [resolve, reject]));
|
|
197
197
|
if (!Exit.isSuccess(executed)) {
|
|
198
198
|
if (Cause.hasInterruptsOnly(executed.cause))
|
|
199
199
|
return yield* Effect.failCause(executed.cause);
|
|
@@ -210,11 +210,11 @@ class PromiseAnyFulfilled {
|
|
|
210
210
|
this.value = value;
|
|
211
211
|
}
|
|
212
212
|
}
|
|
213
|
-
const reactionHandler = (value, method
|
|
213
|
+
const reactionHandler = (value, method) => {
|
|
214
214
|
if (isSupportedCallback(value))
|
|
215
215
|
return value;
|
|
216
216
|
if (typeofValue(value) === "function") {
|
|
217
|
-
throw
|
|
217
|
+
throw typeError(`${method} cannot use this callable as a handler; wrap it in an arrow function, e.g. (value) => tools.ns.tool(value).`);
|
|
218
218
|
}
|
|
219
219
|
return undefined;
|
|
220
220
|
};
|
|
@@ -226,23 +226,23 @@ const reactionExit = (promises, source) => Effect.gen(function* () {
|
|
|
226
226
|
yield* Effect.yieldNow;
|
|
227
227
|
return exit;
|
|
228
228
|
});
|
|
229
|
-
const chainReaction = (runner, promises, source, onFulfilled, onRejected, method
|
|
229
|
+
const chainReaction = (runner, promises, source, onFulfilled, onRejected, method) => {
|
|
230
230
|
return promises.createWithSelf((self) => Effect.gen(function* () {
|
|
231
231
|
const exit = yield* reactionExit(promises, source);
|
|
232
232
|
const handler = Exit.isSuccess(exit) ? onFulfilled : onRejected;
|
|
233
233
|
if (handler === undefined)
|
|
234
234
|
return yield* exit;
|
|
235
|
-
const input = Exit.isSuccess(exit) ? exit.value :
|
|
236
|
-
const result = yield* applyCollectionCallback(runner, handler, method
|
|
237
|
-
return yield* resolvePromiseValue(runner, result,
|
|
235
|
+
const input = Exit.isSuccess(exit) ? exit.value : materialize(runner, Cause.squash(exit.cause));
|
|
236
|
+
const result = yield* applyCollectionCallback(runner, handler, method)([input]);
|
|
237
|
+
return yield* resolvePromiseValue(runner, result, self);
|
|
238
238
|
}));
|
|
239
239
|
};
|
|
240
|
-
const chainFinally = (runner, promises, source, cleanup, method
|
|
240
|
+
const chainFinally = (runner, promises, source, cleanup, method) => promises.create(Effect.gen(function* () {
|
|
241
241
|
const exit = yield* reactionExit(promises, source);
|
|
242
242
|
if (cleanup !== undefined) {
|
|
243
|
-
const result = yield* applyCollectionCallback(runner, cleanup, method
|
|
243
|
+
const result = yield* applyCollectionCallback(runner, cleanup, method)([]);
|
|
244
244
|
const intermediate = yield* promises.create(Effect.gen(function* () {
|
|
245
|
-
yield* runner.settlePromise(yield* resolvePromise(runner, promises, result
|
|
245
|
+
yield* runner.settlePromise(yield* resolvePromise(runner, promises, result));
|
|
246
246
|
return yield* exit;
|
|
247
247
|
}));
|
|
248
248
|
return yield* runner.settlePromise(intermediate);
|
|
@@ -256,21 +256,21 @@ export const promiseGlobal = (runner, promises) => {
|
|
|
256
256
|
name: "Promise",
|
|
257
257
|
length: 1,
|
|
258
258
|
call: requiresNew("Promise"),
|
|
259
|
-
construct: (args
|
|
259
|
+
construct: (args) => constructPromise(runner, promises, args[0]),
|
|
260
260
|
});
|
|
261
261
|
// Combinators are not callbacks: `[p].map(Promise.resolve)` must ask for an arrow function.
|
|
262
262
|
for (const name of promiseStatics) {
|
|
263
263
|
define(promise, name, native(protos, {
|
|
264
264
|
name,
|
|
265
265
|
length: 1,
|
|
266
|
-
call: (_, args
|
|
266
|
+
call: (_, args) => invokePromiseMethod(runner, promises, name, args),
|
|
267
267
|
callback: false,
|
|
268
268
|
}), hidden);
|
|
269
269
|
}
|
|
270
270
|
methods(protos, proto, [
|
|
271
|
-
["then", 2, (thisValue, args
|
|
272
|
-
["catch", 1, (thisValue, args
|
|
273
|
-
["finally", 1, (thisValue, args
|
|
271
|
+
["then", 2, (thisValue, args) => instanceMethod(runner, promises, "then", thisValue, args)],
|
|
272
|
+
["catch", 1, (thisValue, args) => instanceMethod(runner, promises, "catch", thisValue, args)],
|
|
273
|
+
["finally", 1, (thisValue, args) => instanceMethod(runner, promises, "finally", thisValue, args)],
|
|
274
274
|
]);
|
|
275
275
|
return promise;
|
|
276
276
|
};
|
|
@@ -1,8 +1,7 @@
|
|
|
1
|
-
import { type AstNode } from "./model.js";
|
|
2
1
|
/** Values that cannot cross the data boundary. */
|
|
3
2
|
export declare const isRuntimeReference: (value: unknown) => boolean;
|
|
4
3
|
export declare const containsRuntimeReference: (value: unknown) => boolean;
|
|
5
4
|
export declare const containsOpaqueReference: (value: unknown) => boolean;
|
|
6
|
-
export declare const rejectCircularInsertion: (container: object, value: unknown, label: string,
|
|
5
|
+
export declare const rejectCircularInsertion: (container: object, value: unknown, label: string, seen?: Set<object>) => void;
|
|
7
6
|
export declare const describeValue: (value: unknown) => string;
|
|
8
7
|
export declare const typeofValue: (value: unknown) => string;
|
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
import { ToolReference } from "../tool-runtime.js";
|
|
2
|
-
import {
|
|
2
|
+
import { invalidData } from "./model.js";
|
|
3
3
|
import { Callable, getOwn, isWrapper, ownKeys, ProgramArray, ProgramDate, ProgramGenerator, ProgramMap, ProgramObject, ProgramPromise, ProgramRegExp, ProgramSet, ProgramURL, ProgramURLSearchParams, } from "./objects.js";
|
|
4
4
|
/** Values that cannot cross the data boundary. */
|
|
5
5
|
export const isRuntimeReference = (value) => value instanceof Callable ||
|
|
@@ -37,9 +37,9 @@ export const containsRuntimeReference = (value) => find(value, isRuntimeReferenc
|
|
|
37
37
|
// Wrapper values are data here, not opaque interpreter references.
|
|
38
38
|
export const containsOpaqueReference = (value) => find(value, (current) => !isWrapper(current) && isRuntimeReference(current), isWrapper, new Set());
|
|
39
39
|
// Reject cycles before mutation so later boundary walks remain safe.
|
|
40
|
-
export const rejectCircularInsertion = (container, value, label,
|
|
40
|
+
export const rejectCircularInsertion = (container, value, label, seen = new Set()) => {
|
|
41
41
|
if (find(value, (current) => current === container, isRuntimeReference, seen)) {
|
|
42
|
-
throw
|
|
42
|
+
throw invalidData(`${label} contains a circular value.`);
|
|
43
43
|
}
|
|
44
44
|
};
|
|
45
45
|
export const describeValue = (value) => {
|
|
@@ -1,6 +1,5 @@
|
|
|
1
1
|
import { Effect } from "effect";
|
|
2
2
|
import type { Prototypes } from "./intrinsics.js";
|
|
3
|
-
import { type AstNode } from "./model.js";
|
|
4
3
|
import { Callable, ProgramPromise } from "./objects.js";
|
|
5
4
|
export type IteratorCursor<R> = {
|
|
6
5
|
readonly next: Effect.Effect<{
|
|
@@ -11,9 +10,9 @@ export type IteratorCursor<R> = {
|
|
|
11
10
|
};
|
|
12
11
|
/** Everything a native function needs from the realm: calling back into the program and its intrinsic objects. */
|
|
13
12
|
export type Runner<R> = {
|
|
14
|
-
readonly invokeCallable: (callable: unknown, thisValue: unknown, args: Array<unknown
|
|
13
|
+
readonly invokeCallable: (callable: unknown, thisValue: unknown, args: Array<unknown>) => Effect.Effect<unknown, unknown, R>;
|
|
15
14
|
readonly settlePromise: (promise: ProgramPromise) => Effect.Effect<unknown, unknown, never>;
|
|
16
|
-
readonly syncIterator: (value: unknown
|
|
15
|
+
readonly syncIterator: (value: unknown) => Effect.Effect<IteratorCursor<R> | undefined, unknown, R>;
|
|
17
16
|
readonly prototypes: Prototypes;
|
|
18
17
|
};
|
|
19
18
|
export declare const preserveConsumerError: <A, R>(cursor: IteratorCursor<R>, effect: Effect.Effect<A, unknown, R>) => Effect.Effect<A, unknown, R>;
|
|
@@ -21,8 +20,8 @@ export declare const preserveConsumerError: <A, R>(cursor: IteratorCursor<R>, ef
|
|
|
21
20
|
* ToPrimitive: calls `valueOf`/`toString` in hint order and returns the first primitive result. Dates treat the
|
|
22
21
|
* default hint as "string", like their `Symbol.toPrimitive`.
|
|
23
22
|
*/
|
|
24
|
-
export declare const toPrimitive: <R>(runner: Runner<R>, value: unknown, hint: "number" | "string" | "default"
|
|
25
|
-
export declare const toPrimitiveString: <R>(runner: Runner<R>, value: unknown
|
|
26
|
-
export declare const toPrimitiveNumber: <R>(runner: Runner<R>, value: unknown
|
|
23
|
+
export declare const toPrimitive: <R>(runner: Runner<R>, value: unknown, hint: "number" | "string" | "default") => Effect.Effect<unknown, unknown, R>;
|
|
24
|
+
export declare const toPrimitiveString: <R>(runner: Runner<R>, value: unknown) => Effect.Effect<string, unknown, R>;
|
|
25
|
+
export declare const toPrimitiveNumber: <R>(runner: Runner<R>, value: unknown) => Effect.Effect<number, unknown, R>;
|
|
27
26
|
export declare const isSupportedCallback: (value: unknown) => value is Callable;
|
|
28
|
-
export declare const applyCollectionCallback: <R>(runner: Runner<R>, callback: unknown, name: string
|
|
27
|
+
export declare const applyCollectionCallback: <R>(runner: Runner<R>, callback: unknown, name: string) => ((args: Array<unknown>) => Effect.Effect<unknown, unknown, R>);
|
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
import { Effect, Exit } from "effect";
|
|
2
2
|
import { coerceToNumber, coerceToString } from "../stdlib/value.js";
|
|
3
|
-
import {
|
|
3
|
+
import { typeError } from "./model.js";
|
|
4
4
|
import { Callable, get, NativeFunction, ProgramDate, ProgramObject, ProgramPromise } from "./objects.js";
|
|
5
5
|
import { typeofValue } from "./references.js";
|
|
6
6
|
export const preserveConsumerError = (cursor, effect) => Effect.flatMap(Effect.exit(effect), (exit) => Exit.isSuccess(exit)
|
|
@@ -10,7 +10,7 @@ export const preserveConsumerError = (cursor, effect) => Effect.flatMap(Effect.e
|
|
|
10
10
|
* ToPrimitive: calls `valueOf`/`toString` in hint order and returns the first primitive result. Dates treat the
|
|
11
11
|
* default hint as "string", like their `Symbol.toPrimitive`.
|
|
12
12
|
*/
|
|
13
|
-
export const toPrimitive = (runner, value, hint
|
|
13
|
+
export const toPrimitive = (runner, value, hint) => {
|
|
14
14
|
if (!(value instanceof ProgramObject))
|
|
15
15
|
return Effect.succeed(value);
|
|
16
16
|
const asString = hint === "string" || (hint === "default" && value instanceof ProgramDate);
|
|
@@ -20,26 +20,26 @@ export const toPrimitive = (runner, value, hint, node) => {
|
|
|
20
20
|
const callable = get(value, method);
|
|
21
21
|
if (!(callable instanceof Callable))
|
|
22
22
|
continue;
|
|
23
|
-
const result = yield* runner.invokeCallable(callable, value, []
|
|
23
|
+
const result = yield* runner.invokeCallable(callable, value, []);
|
|
24
24
|
if (result === null || (typeof result !== "object" && typeof result !== "function"))
|
|
25
25
|
return result;
|
|
26
26
|
}
|
|
27
|
-
throw
|
|
27
|
+
throw typeError("Cannot convert object to primitive value.");
|
|
28
28
|
});
|
|
29
29
|
};
|
|
30
|
-
export const toPrimitiveString = (runner, value
|
|
31
|
-
export const toPrimitiveNumber = (runner, value
|
|
30
|
+
export const toPrimitiveString = (runner, value) => Effect.map(toPrimitive(runner, value, "string"), coerceToString);
|
|
31
|
+
export const toPrimitiveNumber = (runner, value) => Effect.map(toPrimitive(runner, value, "number"), coerceToNumber);
|
|
32
32
|
// The single acceptance list for callbacks: collections, sort, string replacers,
|
|
33
33
|
// Array.from mappers, and promise reactions all admit exactly these callables.
|
|
34
34
|
// Admission means dispatchable, not necessarily invocable: new-requiring
|
|
35
35
|
// constructors pass the gate and throw a TypeError on call, like JS.
|
|
36
36
|
export const isSupportedCallback = (value) => value instanceof Callable && !(value instanceof NativeFunction && !value.callback);
|
|
37
|
-
export const applyCollectionCallback = (runner, callback, name
|
|
37
|
+
export const applyCollectionCallback = (runner, callback, name) => {
|
|
38
38
|
if (!isSupportedCallback(callback)) {
|
|
39
39
|
if (typeofValue(callback) === "function") {
|
|
40
|
-
throw
|
|
40
|
+
throw typeError(`${name} cannot use this callable as a callback; wrap it in an arrow function, e.g. (value) => tools.ns.tool(value).`);
|
|
41
41
|
}
|
|
42
|
-
throw
|
|
42
|
+
throw typeError(`${name} expects a function callback.`);
|
|
43
43
|
}
|
|
44
|
-
return (callbackArgs) => runner.invokeCallable(callback, undefined, callbackArgs
|
|
44
|
+
return (callbackArgs) => runner.invokeCallable(callback, undefined, callbackArgs);
|
|
45
45
|
};
|