ziex 0.1.0-dev.1466 → 0.1.0-dev.1568

package/wasm/init.dev.js

@@ -275,7 +275,7 @@ var ZigJS = class {
 function createFetchImports(getMemory) {
   const encoder2 = new TextEncoder();
   const decoder2 = new TextDecoder();
-  function readStr(ptr, len) {
+  function readStr2(ptr, len) {
     return decoder2.decode(new Uint8Array(getMemory().buffer, ptr, len));
   }
   function writeBytes2(buf_ptr, buf_max, data) {
@@ -301,9 +301,9 @@ function createFetchImports(getMemory) {
     return headers;
   }
   async function doFetch(url_ptr, url_len, method_ptr, method_len, headers_ptr, headers_len, body_ptr, body_len, timeout_ms, status_out, buf_ptr, buf_max) {
-    const url = readStr(url_ptr, url_len);
-    const method = method_len > 0 ? readStr(method_ptr, method_len) : "GET";
-    const headersJson = headers_len > 0 ? readStr(headers_ptr, headers_len) : "{}";
+    const url = readStr2(url_ptr, url_len);
+    const method = method_len > 0 ? readStr2(method_ptr, method_len) : "GET";
+    const headersJson = headers_len > 0 ? readStr2(headers_ptr, headers_len) : "{}";
     const body = body_len > 0 ? readBytes(body_ptr, body_len) : void 0;
     const headers = parseHeaders(headersJson);
     const controller = new AbortController();
@@ -326,14 +326,14 @@ function createFetchImports(getMemory) {
       return -1;
     }
   }
-  const Suspending = WebAssembly.Suspending;
-  if (typeof Suspending !== "function") {
+  const Suspending2 = WebAssembly.Suspending;
+  if (typeof Suspending2 !== "function") {
     return {
       fetch: (_url_ptr, _url_len, _method_ptr, _method_len, _headers_ptr, _headers_len, _body_ptr, _body_len, _timeout_ms, _status_out, _buf_ptr, _buf_max) => -1
     };
   }
   return {
-    fetch: new Suspending(doFetch)
+    fetch: new Suspending2(doFetch)
   };
 }
 
@@ -804,6 +804,55 @@ var SVG_TAG_START_INDEX = 140;
 var CUSTOM_TAG_INDEX = 199;
 
 // src/wasm/dom_cmd.ts
+var BOOL_PROPS = /* @__PURE__ */ new Set([
+  "checked",
+  "selected",
+  "muted",
+  "defaultChecked",
+  "indeterminate"
+]);
+function enqueueAfterConnect(queue, el, kind) {
+  for (let i = 0; i < queue.length; i++) {
+    const job = queue[i];
+    if (job.el === el && job.kind === kind) return;
+  }
+  queue.push({ el, kind });
+}
+function runAfterConnect(queue) {
+  for (let i = 0; i < queue.length; i++) {
+    const job = queue[i];
+    if (!job.el.isConnected) continue;
+    switch (job.kind) {
+      case "focus": {
+        if (typeof job.el.focus !== "function") break;
+        try {
+          job.el.focus({ preventScroll: true });
+        } catch {
+          job.el.focus();
+        }
+        break;
+      }
+    }
+  }
+}
+function assignProp(el, name, val) {
+  if (BOOL_PROPS.has(name)) {
+    const on = val !== "false";
+    el[name] = on;
+    if (name === "defaultChecked" && "checked" in el) {
+      el.checked = on;
+    }
+    return;
+  }
+  if (name === "defaultValue") {
+    el.defaultValue = val;
+    if (typeof el.value === "string" && (el.value === "" || el.value === el.defaultValue)) {
+      el.value = val;
+    }
+    return;
+  }
+  el[name] = val;
+}
 function flushDomCmds(ptr, len, ctx) {
   const start = ptr >>> 0;
   const length = len >>> 0;
@@ -815,6 +864,7 @@ function flushDomCmds(ptr, len, ctx) {
   const recordsBytes = count * DOM_CMD_RECORD_SIZE;
   if (DOM_CMD_HEADER_SIZE + recordsBytes > length) return;
   const { domNodes: domNodes2, cleanupDomNodes: cleanupDomNodes2 } = ctx;
+  const afterConnect = [];
   for (let i = 0; i < count; i++) {
     const off = DOM_CMD_HEADER_SIZE + i * DOM_CMD_RECORD_SIZE;
     const op = view.getUint8(off);
@@ -847,20 +897,19 @@ function flushDomCmds(ptr, len, ctx) {
         break;
       }
       case DomOp_SetAttr: {
-        domNodes2.get(p0)?.setAttribute(readString(p1, p2), readString(p3, p4));
+        const el = domNodes2.get(p0);
+        if (!el) break;
+        const name = readString(p1, p2);
+        const val = readString(p3, p4);
+        el.setAttribute(name, val);
+        if (name === "autofocus") {
+          enqueueAfterConnect(afterConnect, el, "focus");
+        }
         break;
       }
       case DomOp_SetProp: {
         const el = domNodes2.get(p0);
-        if (el) {
-          const name = readString(p1, p2);
-          const val = readString(p3, p4);
-          if (name === "checked" || name === "selected" || name === "muted") {
-            el[name] = val !== "false";
-          } else {
-            el[name] = val;
-          }
-        }
+        if (el) assignProp(el, readString(p1, p2), readString(p3, p4));
         break;
       }
       case DomOp_RemoveAttr: {
@@ -913,225 +962,208 @@ function flushDomCmds(ptr, len, ctx) {
         break;
     }
   }
+  runAfterConnect(afterConnect);
 }
 
 // src/runtime/kv/extern.ts
+var Suspending = WebAssembly.Suspending;
+var jspi = typeof Suspending === "function";
+var miss = jspi ? -1 : 0;
 function putOptions(ttlSeconds) {
   if (ttlSeconds < 60) return void 0;
   return { expirationTtl: ttlSeconds };
 }
+function kvDel(binding, key) {
+  const b = binding;
+  return (b.del ?? b.delete).call(b, key);
+}
 function isSyncKVNamespace(binding) {
-  const candidate = binding;
-  return typeof candidate.getSync === "function" && typeof candidate.putSync === "function" && typeof candidate.deleteSync === "function" && typeof candidate.listSync === "function";
+  return typeof binding.get === "function" && binding.get.constructor.name !== "AsyncFunction";
 }
-function createKVImports(bindings, getMemory, allocRef) {
-  const encoder2 = new TextEncoder();
-  const decoder2 = new TextDecoder();
-  function readStr(ptr, len) {
-    return decoder2.decode(new Uint8Array(getMemory().buffer, ptr, len));
-  }
-  function binding(ns) {
-    return bindings[ns] ?? bindings["default"] ?? null;
+function listOpts(prefix) {
+  return prefix.length > 0 ? { prefix } : void 0;
+}
+function maybeThen(r, f) {
+  return r instanceof Promise ? r.then(f) : f(r);
+}
+function readStr(getMemory, ptr, len) {
+  return textDecoder.decode(new Uint8Array(getMemory().buffer, ptr, len));
+}
+function resolve(bindings, ns) {
+  const b = bindings[ns] ?? bindings["default"] ?? null;
+  if (!b || jspi) return b;
+  return isSyncKVNamespace(b) ? b : null;
+}
+function encodeGet(getMemory, allocRef, value, out_ptr) {
+  if (value === null) return -1;
+  return writeBytesOut(getMemory, allocRef, out_ptr, textEncoder.encode(value));
+}
+function encodeList(getMemory, allocRef, names, out_ptr) {
+  if (names.length === 0) {
+    new DataView(getMemory().buffer).setUint32(out_ptr, 0, true);
+    return 0;
   }
-  const Suspending = WebAssembly.Suspending;
-  if (typeof Suspending !== "function") {
-    let syncBinding2 = function(ns) {
-      const candidate = binding(ns);
-      return candidate && isSyncKVNamespace(candidate) ? candidate : null;
-    };
-    var syncBinding = syncBinding2;
-    return {
-      kv_get: (ns_ptr, ns_len, key_ptr, key_len, out_ptr) => {
-        const b = syncBinding2(readStr(ns_ptr, ns_len));
-        if (!b) return -1;
-        const value = b.getSync(readStr(key_ptr, key_len));
-        if (value === null) return -1;
-        return writeBytesOut(getMemory, allocRef, out_ptr, encoder2.encode(value));
-      },
-      kv_put: (ns_ptr, ns_len, key_ptr, key_len, val_ptr, val_len, ttl_seconds) => {
-        const b = syncBinding2(readStr(ns_ptr, ns_len));
-        if (!b) return 0;
-        b.putSync(readStr(key_ptr, key_len), readStr(val_ptr, val_len), putOptions(ttl_seconds));
-        return 0;
-      },
-      kv_delete: (ns_ptr, ns_len, key_ptr, key_len) => {
-        const b = syncBinding2(readStr(ns_ptr, ns_len));
-        if (!b) return 0;
-        b.deleteSync(readStr(key_ptr, key_len));
-        return 0;
-      },
-      kv_list: (ns_ptr, ns_len, pfx_ptr, pfx_len, out_ptr) => {
-        const b = syncBinding2(readStr(ns_ptr, ns_len));
-        if (!b) return writeJsonOut(getMemory, allocRef, out_ptr, []);
-        const prefix = readStr(pfx_ptr, pfx_len);
-        const result = b.listSync(prefix.length > 0 ? { prefix } : void 0);
-        return writeJsonOut(getMemory, allocRef, out_ptr, result.keys.map((k) => k.name));
-      }
-    };
+  return writeJsonOut(getMemory, allocRef, out_ptr, names);
+}
+function get(b, key, out_ptr, getMemory, allocRef) {
+  return maybeThen(b.get(key), (v) => encodeGet(getMemory, allocRef, v, out_ptr));
+}
+function put(b, key, val, ttl) {
+  return maybeThen(b.put(key, val, putOptions(ttl)), () => 0);
+}
+function del(b, key) {
+  return maybeThen(kvDel(b, key), () => 0);
+}
+function list(b, prefix, out_ptr, getMemory, allocRef) {
+  return maybeThen(
+    b.list(listOpts(prefix)),
+    (result) => encodeList(getMemory, allocRef, result.keys.map((k) => k.name), out_ptr)
+  );
+}
+function wrapImport(impl) {
+  if (!jspi) {
+    return ((...args) => {
+      const r = impl(...args);
+      if (r instanceof Promise) throw new Error("async kv binding requires JSPI");
+      return r;
+    });
   }
+  return new Suspending(impl);
+}
+function createKVImports(bindings, getMemory, allocRef) {
   return {
-    kv_get: new Suspending(async (ns_ptr, ns_len, key_ptr, key_len, out_ptr) => {
-      const b = binding(readStr(ns_ptr, ns_len));
+    kv_get: wrapImport((ns_ptr, ns_len, key_ptr, key_len, out_ptr) => {
+      const b = resolve(bindings, readStr(getMemory, ns_ptr, ns_len));
       if (!b) return -1;
-      const value = await b.get(readStr(key_ptr, key_len));
-      if (value === null) return -1;
-      return writeBytesOut(getMemory, allocRef, out_ptr, encoder2.encode(value));
+      return get(b, readStr(getMemory, key_ptr, key_len), out_ptr, getMemory, allocRef);
     }),
-    kv_put: new Suspending(async (ns_ptr, ns_len, key_ptr, key_len, val_ptr, val_len, ttl_seconds) => {
-      const b = binding(readStr(ns_ptr, ns_len));
-      if (!b) return -1;
-      await b.put(readStr(key_ptr, key_len), readStr(val_ptr, val_len), putOptions(ttl_seconds));
-      return 0;
+    kv_put: wrapImport((ns_ptr, ns_len, key_ptr, key_len, val_ptr, val_len, ttl_seconds) => {
+      const b = resolve(bindings, readStr(getMemory, ns_ptr, ns_len));
+      if (!b) return miss;
+      return put(
+        b,
+        readStr(getMemory, key_ptr, key_len),
+        readStr(getMemory, val_ptr, val_len),
+        ttl_seconds
+      );
     }),
-    kv_delete: new Suspending(async (ns_ptr, ns_len, key_ptr, key_len) => {
-      const b = binding(readStr(ns_ptr, ns_len));
-      if (!b) return -1;
-      await b.delete(readStr(key_ptr, key_len));
-      return 0;
+    kv_delete: wrapImport((ns_ptr, ns_len, key_ptr, key_len) => {
+      const b = resolve(bindings, readStr(getMemory, ns_ptr, ns_len));
+      if (!b) return miss;
+      return del(b, readStr(getMemory, key_ptr, key_len));
     }),
-    kv_list: new Suspending(async (ns_ptr, ns_len, prefix_ptr, prefix_len, out_ptr) => {
-      const b = binding(readStr(ns_ptr, ns_len));
+    kv_list: wrapImport((ns_ptr, ns_len, pfx_ptr, pfx_len, out_ptr) => {
+      const b = resolve(bindings, readStr(getMemory, ns_ptr, ns_len));
       if (!b) return writeJsonOut(getMemory, allocRef, out_ptr, []);
-      const prefix = readStr(prefix_ptr, prefix_len);
-      const result = await b.list(prefix.length > 0 ? { prefix } : void 0);
-      const names = result.keys.map((k) => k.name);
-      if (names.length === 0) {
-        new DataView(getMemory().buffer).setUint32(out_ptr, 0, true);
-        return 0;
-      }
-      return writeJsonOut(getMemory, allocRef, out_ptr, names);
+      return list(b, readStr(getMemory, pfx_ptr, pfx_len), out_ptr, getMemory, allocRef);
     })
   };
 }
 
 // src/runtime/kv/localstorage.ts
-function getLocalStorage() {
+var namespace = "default";
+var storagePrefix = "ziex-kv";
+var namespacePrefix = `${storagePrefix}:${namespace}:`;
+function storage() {
   if (typeof localStorage === "undefined") {
     throw new Error("localStorage is not available in this environment");
   }
   return localStorage;
 }
-function createLocalStorageKV(options = {}) {
-  const storage = getLocalStorage();
-  const namespace = options.namespace ?? "default";
-  const storagePrefix = options.storagePrefix ?? "ziex-kv";
-  const scopedKey = (key) => `${storagePrefix}:${namespace}:${key}`;
-  const namespacePrefix = scopedKey("");
-  return {
-    getSync(key) {
-      return storage.getItem(scopedKey(key));
-    },
-    async get(key) {
-      return this.getSync(key);
-    },
-    putSync(key, value) {
-      storage.setItem(scopedKey(key), value);
-    },
-    async put(key, value) {
-      this.putSync(key, value);
-    },
-    deleteSync(key) {
-      storage.removeItem(scopedKey(key));
-    },
-    async delete(key) {
-      this.deleteSync(key);
-    },
-    listSync(options2) {
-      const prefix = namespacePrefix + (options2?.prefix ?? "");
-      const keys = [];
-      for (let i = 0; i < storage.length; i += 1) {
-        const key = storage.key(i);
-        if (!key || !key.startsWith(prefix)) continue;
-        keys.push({ name: key.slice(namespacePrefix.length) });
-      }
-      return { keys };
-    },
-    async list(options2) {
-      return this.listSync(options2);
-    }
-  };
+function get2(key) {
+  return storage().getItem(`${storagePrefix}:${namespace}:${key}`);
+}
+function put2(key, value) {
+  storage().setItem(`${storagePrefix}:${namespace}:${key}`, value);
+}
+function del2(key) {
+  storage().removeItem(`${storagePrefix}:${namespace}:${key}`);
+}
+function list2(options) {
+  const ls = storage();
+  const prefix = namespacePrefix + (options?.prefix ?? "");
+  const keys = [];
+  for (let i = 0; i < ls.length; i += 1) {
+    const key = ls.key(i);
+    if (!key || !key.startsWith(prefix)) continue;
+    keys.push({ name: key.slice(namespacePrefix.length) });
+  }
+  return { keys };
 }
 
 // src/runtime/kv/indexdb.ts
-function getIndexedDb() {
-  if (typeof indexedDB === "undefined") {
-    throw new Error("IndexedDB is not available in this environment");
+var databaseName = "ziex-kv";
+var storeName = "kv";
+var namespace2 = "default";
+var dbPromise;
+function openDb() {
+  if (!dbPromise) {
+    if (typeof indexedDB === "undefined") {
+      return Promise.reject(new Error("IndexedDB is not available in this environment"));
+    }
+    dbPromise = new Promise((resolve2, reject) => {
+      const request = indexedDB.open(databaseName, 1);
+      request.onupgradeneeded = () => {
+        const db = request.result;
+        if (!db.objectStoreNames.contains(storeName)) {
+          db.createObjectStore(storeName);
+        }
+      };
+      request.onsuccess = () => resolve2(request.result);
+      request.onerror = () => reject(request.error ?? new Error("Failed to open IndexedDB"));
+    });
   }
-  return indexedDB;
+  return dbPromise;
 }
 function requestToPromise(request) {
-  return new Promise((resolve, reject) => {
-    request.onsuccess = () => resolve(request.result);
+  return new Promise((resolve2, reject) => {
+    request.onsuccess = () => resolve2(request.result);
     request.onerror = () => reject(request.error ?? new Error("IndexedDB request failed"));
   });
 }
 function transactionToPromise(transaction) {
-  return new Promise((resolve, reject) => {
-    transaction.oncomplete = () => resolve();
+  return new Promise((resolve2, reject) => {
+    transaction.oncomplete = () => resolve2();
     transaction.onabort = () => reject(transaction.error ?? new Error("IndexedDB transaction aborted"));
     transaction.onerror = () => reject(transaction.error ?? new Error("IndexedDB transaction failed"));
   });
 }
-function createIndexedDbKV(options = {}) {
-  const databaseName = options.databaseName ?? "ziex-kv";
-  const storeName = options.storeName ?? "kv";
-  const namespace = options.namespace ?? "default";
-  const dbPromise = new Promise((resolve, reject) => {
-    const request = getIndexedDb().open(databaseName, 1);
-    request.onupgradeneeded = () => {
-      const db = request.result;
-      if (!db.objectStoreNames.contains(storeName)) {
-        db.createObjectStore(storeName);
-      }
-    };
-    request.onsuccess = () => resolve(request.result);
-    request.onerror = () => reject(request.error ?? new Error("Failed to open IndexedDB"));
-  });
-  const scopedKey = (key) => `${namespace}:${key}`;
+async function get3(key) {
+  const db = await openDb();
+  const tx = db.transaction(storeName, "readonly");
+  const value = await requestToPromise(tx.objectStore(storeName).get(`${namespace2}:${key}`));
+  await transactionToPromise(tx);
+  return typeof value === "string" ? value : null;
+}
+async function put3(key, value) {
+  const db = await openDb();
+  const tx = db.transaction(storeName, "readwrite");
+  tx.objectStore(storeName).put(value, `${namespace2}:${key}`);
+  await transactionToPromise(tx);
+}
+async function del3(key) {
+  const db = await openDb();
+  const tx = db.transaction(storeName, "readwrite");
+  tx.objectStore(storeName).delete(`${namespace2}:${key}`);
+  await transactionToPromise(tx);
+}
+async function list3(options) {
+  const db = await openDb();
+  const tx = db.transaction(storeName, "readonly");
+  const keys = await requestToPromise(tx.objectStore(storeName).getAllKeys());
+  await transactionToPromise(tx);
+  const prefix = `${namespace2}:${options?.prefix ?? ""}`;
   return {
-    async get(key) {
-      const db = await dbPromise;
-      const tx = db.transaction(storeName, "readonly");
-      const store = tx.objectStore(storeName);
-      const value = await requestToPromise(store.get(scopedKey(key)));
-      await transactionToPromise(tx);
-      return typeof value === "string" ? value : null;
-    },
-    async put(key, value) {
-      const db = await dbPromise;
-      const tx = db.transaction(storeName, "readwrite");
-      tx.objectStore(storeName).put(value, scopedKey(key));
-      await transactionToPromise(tx);
-    },
-    async delete(key) {
-      const db = await dbPromise;
-      const tx = db.transaction(storeName, "readwrite");
-      tx.objectStore(storeName).delete(scopedKey(key));
-      await transactionToPromise(tx);
-    },
-    async list(options2) {
-      const db = await dbPromise;
-      const tx = db.transaction(storeName, "readonly");
-      const store = tx.objectStore(storeName);
-      const keys = await requestToPromise(store.getAllKeys());
-      await transactionToPromise(tx);
-      const prefix = scopedKey(options2?.prefix ?? "");
-      return {
-        keys: keys.filter((key) => typeof key === "string" && key.startsWith(prefix)).map((key) => ({ name: key.slice(namespace.length + 1) }))
-      };
-    }
+    keys: keys.filter((key) => typeof key === "string" && key.startsWith(prefix)).map((key) => ({ name: key.slice(namespace2.length + 1) }))
   };
 }
 
 // src/runtime/kv.ts
-function hasJSPI() {
-  return typeof WebAssembly.Suspending === "function" && typeof WebAssembly.promising === "function";
-}
+var hasJspi = typeof WebAssembly.Suspending === "function" && typeof WebAssembly.promising === "function";
 function createBrowserKVBindings(options = {}) {
-  const namespace = options.namespace ?? "default";
-  const isIndexedDb = hasJSPI() && !options.forceLocalStorage;
+  const namespace3 = options.namespace ?? "default";
   return {
-    [namespace]: isIndexedDb ? createIndexedDbKV(options) : createLocalStorageKV(options)
+    [namespace3]: hasJspi && !options.forceLocalStorage ? { get: get3, put: put3, del: del3, list: list3 } : { get: get2, put: put2, del: del2, list: list2 }
   };
 }
 
@@ -1403,6 +1435,10 @@ var ZxBridge = class extends ZxBridgeCore {
           if (!form || !(form instanceof HTMLFormElement)) return;
           const statesJson = statesLen > 0 ? readString(statesPtr, statesLen) : "[]";
           bridgeRef[0]?.submitFormActionAsync(form, actionId, statesJson, fetchId);
+        },
+        _formReset: (vnodeId) => {
+          const form = domNodes.get(Number(vnodeId));
+          if (form instanceof HTMLFormElement) form.reset();
         }
       }
     };