@scriptc/cli-darwin-arm64 0.2.1 → 0.2.2

package/dist/lib/runtime-sources/src/scr_web.c

@@ -62,43 +62,77 @@ static const char web_prelude[] =
     "   * (host.setTimer/host.clearTimer) — REF'd like Node's (an armed\n"
     "   * timer keeps the process alive), FIFO-ordered against static\n"
     "   * timers on one heap, Node's <1ms clamp. Returns a Timeout-shaped\n"
-    "   * object (ref/unref/refresh/close, numeric via toPrimitive) that\n"
-    "   * clearTimeout/clearInterval accept alongside plain ids; unref is\n"
-    "   * accepted but not honored (the entry stays ref'd — a documented\n"
-    "   * approximation). */\n"
+    "   * object with real ref/unref/refresh/close operations. Immediates\n"
+    "   * use the native check queue, independently of timer ids. */\n"
+    "  const timers = new Map();\n"
     "  class Timeout {\n"
-    "    constructor(fn, delay, repeat) {\n"
+    "    constructor(fn, delay, args, repeat) {\n"
     "      this._fn = fn;\n"
     "      this._delay = delay;\n"
+    "      this._args = args;\n"
     "      this._repeat = repeat;\n"
-    "      this._id = host.setTimer(fn, delay, repeat);\n"
+    "      this._reffed = true;\n"
+    "      this._closed = false;\n"
+    "      this._callback = () => {\n"
+    "        if (!this._repeat) { this._destroyed = true; timers.delete(this._id); }\n"
+    "        this._fn.apply(this, this._args);\n"
+    "      };\n"
+    "      this._arm();\n"
     "    }\n"
-    "    ref() { return this; }\n"
-    "    unref() { return this; }\n"
-    "    hasRef() { return true; }\n"
+    "    _arm() {\n"
+    "      this._destroyed = false;\n"
+    "      this._id = host.setTimer(this._callback, this._delay, this._repeat, false);\n"
+    "      timers.set(this._id, this);\n"
+    "      if (!this._reffed) host.refTimer(this._id, false, false);\n"
+    "    }\n"
+    "    ref() { this._reffed = true; host.refTimer(this._id, true, false); return this; }\n"
+    "    unref() { this._reffed = false; host.refTimer(this._id, false, false); return this; }\n"
+    "    hasRef() { return this._reffed; }\n"
     "    refresh() {\n"
-    "      host.clearTimer(this._id);\n"
-    "      this._id = host.setTimer(this._fn, this._delay, this._repeat);\n"
+    "      if (this._closed) return this;\n"
+    "      if (this._destroyed) this._arm();\n"
+    "      else host.refreshTimer(this._id);\n"
     "      return this;\n"
     "    }\n"
-    "    close() { host.clearTimer(this._id); return this; }\n"
+    "    close() { this._closed = true; this._destroyed = true; timers.delete(this._id); host.clearTimer(this._id, false); return this; }\n"
+    "    [Symbol.dispose]() { this.close(); }\n"
     "    [Symbol.toPrimitive]() { return this._id; }\n"
     "  }\n"
     "  const mkTimer = (fn, ms, args, repeat) => {\n"
     "    if (typeof fn !== 'function') {\n"
     "      throw new TypeError('The \"callback\" argument must be of type function. Received type ' + typeof fn);\n"
     "    }\n"
-    "    const cb = args.length === 0 ? fn : () => fn(...args);\n"
-    "    return new Timeout(cb, Number(ms), repeat);\n"
+    "    return new Timeout(fn, Number(ms), args, repeat);\n"
     "  };\n"
     "  g.setTimeout = (fn, ms, ...args) => mkTimer(fn, ms, args, false);\n"
     "  g.setInterval = (fn, ms, ...args) => mkTimer(fn, ms, args, true);\n"
     "  g.clearTimeout = (t) => {\n"
     "    if (t === undefined || t === null) return;\n"
     "    const id = typeof t === 'number' ? t : Number(t);\n"
-    "    if (Number.isFinite(id)) host.clearTimer(id);\n"
+    "    if (Number.isFinite(id)) {\n"
+    "      const timer = timers.get(id);\n"
+    "      if (timer) timer.close(); else host.clearTimer(id, false);\n"
+    "    }\n"
     "  };\n"
     "  g.clearInterval = g.clearTimeout;\n"
+    "  class Immediate {\n"
+    "    constructor(fn, args) {\n"
+    "      this._reffed = true; this._destroyed = false;\n"
+    "      this._id = host.setTimer(() => {\n"
+    "        this._destroyed = true; this._reffed = false; fn.apply(this, args);\n"
+    "      }, 0, false, true);\n"
+    "    }\n"
+    "    ref() { if (!this._destroyed) { this._reffed = true; host.refTimer(this._id, true, true); } return this; }\n"
+    "    unref() { if (!this._destroyed) { this._reffed = false; host.refTimer(this._id, false, true); } return this; }\n"
+    "    hasRef() { return this._reffed; }\n"
+    "    _close() { this._destroyed = true; this._reffed = false; host.clearTimer(this._id, true); }\n"
+    "    [Symbol.dispose]() { this._close(); }\n"
+    "  }\n"
+    "  g.setImmediate = (fn, ...args) => {\n"
+    "    if (typeof fn !== 'function') throw new TypeError('The \"callback\" argument must be of type function. Received type ' + typeof fn);\n"
+    "    return new Immediate(fn, args);\n"
+    "  };\n"
+    "  g.clearImmediate = (immediate) => { if (immediate instanceof Immediate) immediate._close(); };\n"
     "\n"
     "  class ReadableStream {\n"
     "    constructor(source, _strategy) {\n"
@@ -503,8 +537,41 @@ static const char web_prelude[] =
     "  g.TransformStream = TransformStream;\n"
     "\n"
     "\n"
+    "  const textEncoders = new WeakSet();\n"
     "  class TextEncoder {\n"
+    "    constructor() { textEncoders.add(this); }\n"
     "    get encoding() { return 'utf-8'; }\n"
+    "    encodeInto(src, dest) {\n"
+    "      const fail = (name, expected, value) => {\n"
+    "        let received;\n"
+    "        if (value === null || value === undefined) received = String(value);\n"
+    "        else if (typeof value === 'object' || typeof value === 'function') received = 'an instance of ' + (value.constructor && value.constructor.name || 'Object');\n"
+    "        else if (typeof value === 'string') received = \"type string ('\" + value + \"')\";\n"
+    "        else received = 'type ' + typeof value + ' (' + String(value) + (typeof value === 'bigint' ? 'n' : '') + ')';\n"
+    "        const error = new TypeError('The \"' + name + '\" argument must be ' + expected + '. Received ' + received);\n"
+    "        error.code = 'ERR_INVALID_ARG_TYPE'; throw error;\n"
+    "      };\n"
+    "      if (!textEncoders.has(this)) { const error = new TypeError('Value of \"this\" must be of type TextEncoder'); error.code = 'ERR_INVALID_THIS'; throw error; }\n"
+    "      if (typeof src !== 'string') fail('src', 'of type string', src);\n"
+    "      if (!(dest instanceof Uint8Array)) fail('dest', 'an instance of Uint8Array', dest);\n"
+    "      let read = 0, written = 0;\n"
+    "      while (read < src.length) {\n"
+    "        let cp = src.charCodeAt(read), units = 1;\n"
+    "        if (cp >= 0xd800 && cp <= 0xdbff) {\n"
+    "          const low = src.charCodeAt(read + 1);\n"
+    "          if (low >= 0xdc00 && low <= 0xdfff) { cp = 0x10000 + ((cp - 0xd800) << 10) + low - 0xdc00; units = 2; }\n"
+    "          else cp = 0xfffd;\n"
+    "        } else if (cp >= 0xdc00 && cp <= 0xdfff) cp = 0xfffd;\n"
+    "        const size = cp < 0x80 ? 1 : cp < 0x800 ? 2 : cp < 0x10000 ? 3 : 4;\n"
+    "        if (written + size > dest.length) break;\n"
+    "        if (size === 1) dest[written++] = cp;\n"
+    "        else if (size === 2) { dest[written++] = 0xc0 | (cp >> 6); dest[written++] = 0x80 | (cp & 63); }\n"
+    "        else if (size === 3) { dest[written++] = 0xe0 | (cp >> 12); dest[written++] = 0x80 | ((cp >> 6) & 63); dest[written++] = 0x80 | (cp & 63); }\n"
+    "        else { dest[written++] = 0xf0 | (cp >> 18); dest[written++] = 0x80 | ((cp >> 12) & 63); dest[written++] = 0x80 | ((cp >> 6) & 63); dest[written++] = 0x80 | (cp & 63); }\n"
+    "        read += units;\n"
+    "      }\n"
+    "      return { read, written };\n"
+    "    }\n"
     "    encode(input) {\n"
     "      const s = input === undefined ? '' : String(input);\n"
     "      const bytes = [];\n"
@@ -891,13 +958,14 @@ static const char web_prelude[] =
     "      const once = !!(options !== null && typeof options === 'object' && options.once);\n"
     "      const list = this._et[t] || (this._et[t] = []);\n"
     "      for (const e of list) { if (e.listener === listener) return; }\n"
-    "      list.push({ listener, once });\n"
+    "      const resistant = !!(options && options[Symbol.for('scriptc.events.resistStopPropagation')]);\n"
+    "      list.push({ listener, once, resistant });\n"
     "    }\n"
     "    removeEventListener(type, listener) {\n"
     "      const list = this._et[String(type)];\n"
     "      if (!list) return;\n"
     "      const i = list.findIndex((e) => e.listener === listener);\n"
-    "      if (i >= 0) list.splice(i, 1);\n"
+    "      if (i >= 0) list.splice(i, 1)[0].removed = true;\n"
     "    }\n"
     "    dispatchEvent(event) {\n"
     "      if (!(event instanceof Event)) throw new TypeError('The \"event\" argument must be an instance of Event.');\n"
@@ -907,7 +975,8 @@ static const char web_prelude[] =
     "      const list = this._et[event.type];\n"
     "      if (list) {\n"
     "        for (const e of [...list]) {\n"
-    "          if (event._stopImmediate) break;\n"
+    "          if (e.removed) continue;\n"
+    "          if (event._stopImmediate && !e.resistant) continue;\n"
     "          if (e.once) this.removeEventListener(event.type, e.listener);\n"
     "          if (typeof e.listener === 'function') e.listener.call(this, event);\n"
     "          else if (e.listener !== null && typeof e.listener.handleEvent === 'function') e.listener.handleEvent(event);\n"
@@ -1054,13 +1123,16 @@ static const char web_prelude[] =
     "    if (s._aborted) return;\n"
     "    s._aborted = true;\n"
     "    s._reason = reason === undefined ? mkAbortError() : reason;\n"
-    "    const ev = { type: 'abort', target: s, currentTarget: s };\n"
+    "    const ev = new Event('abort');\n"
+    "    ev.target = s; ev.currentTarget = s; ev.eventPhase = Event.AT_TARGET; ev.isTrusted = true;\n"
     "    let firstErr;\n"
     "    let threw = false;\n"
     "    if (s._onabort !== null) {\n"
     "      try { s._onabort.call(s, ev); } catch (e) { firstErr = e; threw = true; }\n"
     "    }\n"
     "    for (const l of s._listeners.slice()) {\n"
+    "      if (l.removed) continue;\n"
+    "      if (ev._stopImmediate && !l.resistant) continue;\n"
     "      if (l.once) s.removeEventListener('abort', l.fn);\n"
     "      try { l.fn.call(s, ev); } catch (e) { if (!threw) { firstErr = e; threw = true; } }\n"
     "    }\n"
@@ -1076,13 +1148,15 @@ static const char web_prelude[] =
     "    throwIfAborted() { if (this._aborted) throw this._reason; }\n"
     "    addEventListener(type, fn, options) {\n"
     "      if (String(type) !== 'abort' || typeof fn !== 'function') return;\n"
+    "      if (this._listeners.some(l => l.fn === fn)) return;\n"
     "      const once = options !== undefined && options !== null && !!options.once;\n"
-    "      this._listeners.push({ fn, once });\n"
+    "      const resistant = !!(options && options[Symbol.for('scriptc.events.resistStopPropagation')]);\n"
+    "      this._listeners.push({ fn, once, resistant });\n"
     "    }\n"
     "    removeEventListener(type, fn) {\n"
     "      if (String(type) !== 'abort') return;\n"
     "      const i = this._listeners.findIndex((l) => l.fn === fn);\n"
-    "      if (i >= 0) this._listeners.splice(i, 1);\n"
+    "      if (i >= 0) this._listeners.splice(i, 1)[0].removed = true;\n"
     "    }\n"
     "    static abort(reason) {\n"
     "      const s = mkSignal();\n"
@@ -1633,7 +1707,6 @@ static void web_timer_fire_cb(ScrClosure *env) {
 static JSValue web_host_set_timer(JSContext *ctx, JSValueConst this_val,
                                   int argc, JSValueConst *argv) {
   (void)this_val;
-  (void)argc;
   double ms = 0;
   if (JS_ToFloat64(ctx, &ms, argv[1])) return JS_EXCEPTION;
   bool repeat = JS_ToBool(ctx, argv[2]) > 0;
@@ -1649,17 +1722,45 @@ static JSValue web_host_set_timer(JSContext *ctx, JSValueConst this_val,
   scr_box_set_ref(box, h); /* the box owns the +1 */
   ScrClosure *cb = scr_closure_new((void *)web_timer_fire_cb, 1);
   cb->caps[0] = box;
-  double id = repeat ? scr_set_interval(cb, ms) : scr_set_timeout_handle(cb, ms);
+  bool immediate = argc > 3 && JS_ToBool(ctx, argv[3]) > 0;
+  double id = immediate ? scr_set_immediate(cb)
+                        : repeat ? scr_set_interval(cb, ms) : scr_set_timeout_handle(cb, ms);
   return JS_NewFloat64(ctx, id);
 }
 
 static JSValue web_host_clear_timer(JSContext *ctx, JSValueConst this_val,
                                     int argc, JSValueConst *argv) {
   (void)this_val;
+  double id = 0;
+  if (JS_ToFloat64(ctx, &id, argv[0])) return JS_EXCEPTION;
+  if (argc > 1 && JS_ToBool(ctx, argv[1]) > 0) scr_clear_immediate(id);
+  else scr_clear_interval(id);
+  return JS_UNDEFINED;
+}
+
+static JSValue web_host_ref_timer(JSContext *ctx, JSValueConst this_val,
+                                int argc, JSValueConst *argv) {
+  (void)this_val;
+  (void)argc;
+  double id = 0;
+  if (JS_ToFloat64(ctx, &id, argv[0])) return JS_EXCEPTION;
+  bool reffed = JS_ToBool(ctx, argv[1]) > 0;
+  bool immediate = JS_ToBool(ctx, argv[2]) > 0;
+  if (immediate) {
+    if (reffed) scr_immediate_ref(id); else scr_immediate_unref(id);
+  } else {
+    if (reffed) scr_timer_ref(id); else scr_timer_unref(id);
+  }
+  return JS_UNDEFINED;
+}
+
+static JSValue web_host_refresh_timer(JSContext *ctx, JSValueConst this_val,
+                                    int argc, JSValueConst *argv) {
+  (void)this_val;
   (void)argc;
   double id = 0;
   if (JS_ToFloat64(ctx, &id, argv[0])) return JS_EXCEPTION;
-  scr_clear_interval(id);
+  scr_timer_refresh(id);
   return JS_UNDEFINED;
 }
 
@@ -1837,8 +1938,10 @@ void scr_island_web_boot(void *jsctx) {
   JS_SetPropertyStr(ctx, host, "write", JS_NewCFunction(ctx, web_host_write, "write", 2));
   JS_SetPropertyStr(ctx, host, "tzname", JS_NewCFunction(ctx, web_host_tzname, "tzname", 1));
   JS_SetPropertyStr(ctx, host, "timer", JS_NewCFunction(ctx, web_host_timer, "timer", 2));
-  JS_SetPropertyStr(ctx, host, "setTimer", JS_NewCFunction(ctx, web_host_set_timer, "setTimer", 3));
-  JS_SetPropertyStr(ctx, host, "clearTimer", JS_NewCFunction(ctx, web_host_clear_timer, "clearTimer", 1));
+  JS_SetPropertyStr(ctx, host, "setTimer", JS_NewCFunction(ctx, web_host_set_timer, "setTimer", 4));
+  JS_SetPropertyStr(ctx, host, "clearTimer", JS_NewCFunction(ctx, web_host_clear_timer, "clearTimer", 2));
+  JS_SetPropertyStr(ctx, host, "refTimer", JS_NewCFunction(ctx, web_host_ref_timer, "refTimer", 3));
+  JS_SetPropertyStr(ctx, host, "refreshTimer", JS_NewCFunction(ctx, web_host_refresh_timer, "refreshTimer", 1));
   JSValue r = JS_Call(ctx, fn, JS_UNDEFINED, 1, (JSValueConst *)&host);
   JS_FreeValue(ctx, host);
   JS_FreeValue(ctx, fn);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scriptc/cli-darwin-arm64",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Native scriptc compiler for darwin-arm64",
   "license": "Apache-2.0",
   "homepage": "https://scriptc.dev",