clawmini 0.0.8 → 0.0.9

package/web/.svelte-kit/output/server/remote-entry.js

@@ -1,9 +1,9 @@
 import { get_request_store, with_request_store } from "@sveltejs/kit/internal/server";
 import { parse } from "devalue";
 import { error, json } from "@sveltejs/kit";
-import { u as stringify_remote_arg, M as MUTATIVE_METHODS, v as create_field_proxy, w as normalize_issue, x as set_nested_value, y as flatten_issues, z as deep_set, k as stringify, f as create_remote_key, h as handle_error_and_jsonify } from "./chunks/shared.js";
+import { x as stringify_remote_arg, j as create_remote_key, y as unfriendly_hydratable, e as noop, l as stringify, M as MUTATIVE_METHODS, z as create_field_proxy, A as normalize_issue, B as set_nested_value, C as flatten_issues, D as deep_set, h as handle_error_and_jsonify, p as parse_remote_arg } from "./chunks/shared.js";
 import { ValidationError, HttpError, SvelteKitError } from "@sveltejs/kit/internal";
-import { B as BROWSER } from "./chunks/false.js";
+import { B as BROWSER } from "./chunks/render-context.js";
 import { b as base, c as app_dir, p as prerendering } from "./chunks/environment.js";
 function create_validator(validate_or_fn, maybe_fn) {
   if (!maybe_fn) {
@@ -36,10 +36,22 @@ function create_validator(validate_or_fn, maybe_fn) {
     'Invalid validator passed to remote function. Expected "unchecked" or a Standard Schema (https://standardschema.dev)'
   );
 }
-async function get_response(info, arg, state, get_result) {
+async function get_response(internals, arg, state, get_result) {
   await 0;
-  const cache = get_cache(info, state);
-  return cache[stringify_remote_arg(arg, state.transport)] ??= get_result();
+  const cache = get_cache(internals, state);
+  const key = stringify_remote_arg(arg, state.transport);
+  const entry = cache[key] ??= {
+    serialize: false,
+    data: get_result()
+  };
+  entry.serialize ||= !!state.is_in_universal_load;
+  if (state.is_in_render && internals.id) {
+    const remote_key = create_remote_key(internals.id, key);
+    Promise.resolve(entry.data).then((value) => {
+      void unfriendly_hydratable(remote_key, () => stringify(value, state.transport));
+    }).catch(noop);
+  }
+  return entry.data;
 }
 function parse_remote_response(data, transport) {
   const revivers = {};
@@ -85,11 +97,11 @@ async function run_remote_function(event, state, allow_cookies, get_input, fn) {
   const input = await with_request_store(store, get_input);
   return with_request_store(store, () => fn(input));
 }
-function get_cache(info, state = get_request_store().state) {
-  let cache = state.remote_data?.get(info);
+function get_cache(internals, state = get_request_store().state) {
+  let cache = state.remote.data?.get(internals);
   if (cache === void 0) {
     cache = {};
-    (state.remote_data ??= /* @__PURE__ */ new Map()).set(info, cache);
+    (state.remote.data ??= /* @__PURE__ */ new Map()).set(internals, cache);
   }
   return cache;
 }
@@ -100,13 +112,17 @@ function command(validate_or_fn, maybe_fn) {
   const __ = { type: "command", id: "", name: "" };
   const wrapper = (arg) => {
     const { event, state } = get_request_store();
-    if (!state.allows_commands) {
-      const disallowed_method = !MUTATIVE_METHODS.includes(event.request.method);
+    if (!MUTATIVE_METHODS.includes(event.request.method)) {
+      throw new Error(
+        `Cannot call a command (\`${__.name}(${maybe_fn ? "..." : ""})\`) from a ${event.request.method} handler`
+      );
+    }
+    if (state.is_in_render) {
       throw new Error(
-        `Cannot call a command (\`${__.name}(${maybe_fn ? "..." : ""})\`) ${disallowed_method ? `from a ${event.request.method} handler or ` : ""}during server-side rendering`
+        `Cannot call a command (\`${__.name}(${maybe_fn ? "..." : ""})\`) during server-side rendering`
       );
     }
-    state.refreshes ??= {};
+    state.remote.refreshes ??= {};
     const promise = Promise.resolve(
       run_remote_function(event, state, true, () => validate(arg), fn)
     );
@@ -157,7 +173,7 @@ function form(validate_or_fn, maybe_fn) {
           if (validated !== void 0) {
             data = validated.value;
           }
-          state.refreshes ??= {};
+          state.remote.refreshes ??= {};
           const issue = create_issues();
           try {
             output.result = await run_remote_function(
@@ -176,7 +192,7 @@ function form(validate_or_fn, maybe_fn) {
           }
         }
         if (!event.isRemoteRequest) {
-          get_cache(__, state)[""] ??= output;
+          get_cache(__, state)[""] ??= { serialize: true, data: output };
         }
         return output;
       }
@@ -190,29 +206,29 @@ function form(validate_or_fn, maybe_fn) {
       get() {
         return create_field_proxy(
           {},
-          () => get_cache(__)?.[""]?.input ?? {},
+          () => get_cache(__)?.[""]?.data?.input ?? {},
           (path, value) => {
             const cache = get_cache(__);
-            const data = cache[""];
-            if (data?.submission) {
+            const entry = cache[""];
+            if (entry?.data?.submission) {
               return;
             }
             if (path.length === 0) {
-              (cache[""] ??= {}).input = value;
+              (cache[""] ??= { serialize: true, data: {} }).data.input = value;
               return;
             }
-            const input = data?.input ?? {};
+            const input = entry?.data?.input ?? {};
             deep_set(input, path.map(String), value);
-            (cache[""] ??= {}).input = input;
+            (cache[""] ??= { serialize: true, data: {} }).data.input = input;
           },
-          () => flatten_issues(get_cache(__)?.[""]?.issues ?? [])
+          () => flatten_issues(get_cache(__)?.[""]?.data?.issues ?? [])
         );
       }
     });
     Object.defineProperty(instance, "result", {
       get() {
         try {
-          return get_cache(__)?.[""]?.result;
+          return get_cache(__)?.[""]?.data?.result;
         } catch {
           return void 0;
         }
@@ -236,12 +252,12 @@ function form(validate_or_fn, maybe_fn) {
         value: (key2) => {
           const { state } = get_request_store();
           const cache_key = __.id + "|" + JSON.stringify(key2);
-          let instance2 = (state.form_instances ??= /* @__PURE__ */ new Map()).get(cache_key);
+          let instance2 = (state.remote.forms ??= /* @__PURE__ */ new Map()).get(cache_key);
           if (!instance2) {
             instance2 = create_instance(key2);
             instance2.__.id = `${__.id}/${encodeURIComponent(JSON.stringify(key2))}`;
             instance2.__.name = __.name;
-            state.form_instances.set(cache_key, instance2);
+            state.remote.forms.set(cache_key, instance2);
           }
           return instance2;
         }
@@ -341,8 +357,9 @@ function prerender(validate_or_fn, fn_or_options, maybe_options) {
           return await get_response(__, arg, state, async () => {
             const key = stringify_remote_arg(arg, state.transport);
             const cache = get_cache(__, state);
-            const promise3 = cache[key] ??= fetch(new URL(url, event.url.origin).href).then(
-              async (response) => {
+            const promise3 = (cache[key] ??= {
+              serialize: true,
+              data: fetch(new URL(url, event.url.origin).href).then(async (response) => {
                 if (!response.ok) {
                   throw new Error("Prerendered response not found");
                 }
@@ -351,8 +368,8 @@ function prerender(validate_or_fn, fn_or_options, maybe_options) {
                   error(prerendered.status, prerendered.error);
                 }
                 return prerendered.result;
-              }
-            );
+              })
+            }).data;
             return parse_remote_response(await promise3, state.transport);
           });
         } catch {
@@ -383,8 +400,7 @@ function prerender(validate_or_fn, fn_or_options, maybe_options) {
       }
       return result;
     })();
-    promise.catch(() => {
-    });
+    promise.catch(noop);
     return (
       /** @type {RemoteResource<Output>} */
       promise
@@ -397,7 +413,7 @@ function prerender(validate_or_fn, fn_or_options, maybe_options) {
 function query(validate_or_fn, maybe_fn) {
   const fn = maybe_fn ?? validate_or_fn;
   const validate = create_validator(validate_or_fn, maybe_fn);
-  const __ = { type: "query", id: "", name: "" };
+  const __ = { type: "query", id: "", name: "", validate };
   const wrapper = (arg) => {
     if (prerendering) {
       throw new Error(
@@ -405,28 +421,30 @@ function query(validate_or_fn, maybe_fn) {
       );
     }
     const { event, state } = get_request_store();
-    const get_remote_function_result = () => run_remote_function(event, state, false, () => validate(arg), fn);
-    const promise = get_response(__, arg, state, get_remote_function_result);
-    promise.catch(() => {
-    });
-    promise.set = (value) => update_refresh_value(get_refresh_context(__, "set", arg), value);
-    promise.refresh = () => {
-      const refresh_context = get_refresh_context(__, "refresh", arg);
-      const is_immediate_refresh = !refresh_context.cache[refresh_context.cache_key];
-      const value = is_immediate_refresh ? promise : get_remote_function_result();
-      return update_refresh_value(refresh_context, value, is_immediate_refresh);
-    };
-    promise.withOverride = () => {
-      throw new Error(`Cannot call '${__.name}.withOverride()' on the server`);
-    };
-    return (
-      /** @type {RemoteQuery<Output>} */
-      promise
+    const is_validated = is_validated_argument(__, state, arg);
+    return create_query_resource(
+      __,
+      arg,
+      state,
+      () => run_remote_function(event, state, false, () => is_validated ? arg : validate(arg), fn)
     );
   };
   Object.defineProperty(wrapper, "__", { value: __ });
   return wrapper;
 }
+function is_validated_argument(__, state, arg) {
+  return state.remote.validated?.get(__.id)?.has(arg) ?? false;
+}
+function mark_argument_validated(__, state, arg) {
+  const validated = state.remote.validated ??= /* @__PURE__ */ new Map();
+  let validated_args = validated.get(__.id);
+  if (!validated_args) {
+    validated_args = /* @__PURE__ */ new Set();
+    validated.set(__.id, validated_args);
+  }
+  validated_args.add(arg);
+  return arg;
+}
 // @__NO_SIDE_EFFECTS__
 function batch(validate_or_fn, maybe_fn) {
   const fn = maybe_fn ?? validate_or_fn;
@@ -447,7 +465,8 @@ function batch(validate_or_fn, maybe_fn) {
           return Promise.all(
             input.map(async (arg, i) => {
               try {
-                return { type: "result", data: get_result(arg, i) };
+                const data = get_result(arg, i);
+                return { type: "result", data: stringify(data, state.transport) };
               } catch (error2) {
                 return {
                   type: "error",
@@ -461,7 +480,7 @@ function batch(validate_or_fn, maybe_fn) {
       );
     }
   };
-  let batching = { args: [], resolvers: [] };
+  let batching = /* @__PURE__ */ new Map();
   const wrapper = (arg) => {
     if (prerendering) {
       throw new Error(
@@ -469,64 +488,112 @@ function batch(validate_or_fn, maybe_fn) {
       );
     }
     const { event, state } = get_request_store();
-    const get_remote_function_result = () => {
+    return create_query_resource(__, arg, state, () => {
       return new Promise((resolve, reject) => {
-        batching.args.push(arg);
-        batching.resolvers.push({ resolve, reject });
-        if (batching.args.length > 1) return;
+        const key = stringify_remote_arg(arg, state.transport);
+        const entry = batching.get(key);
+        if (entry) {
+          entry.resolvers.push({ resolve, reject });
+          return;
+        }
+        batching.set(key, {
+          arg,
+          resolvers: [{ resolve, reject }]
+        });
+        if (batching.size > 1) return;
         setTimeout(async () => {
           const batched = batching;
-          batching = { args: [], resolvers: [] };
+          batching = /* @__PURE__ */ new Map();
+          const entries = Array.from(batched.values());
+          const args = entries.map((entry2) => entry2.arg);
           try {
             return await run_remote_function(
               event,
               state,
               false,
-              async () => Promise.all(batched.args.map(validate)),
+              async () => Promise.all(args.map(validate)),
               async (input) => {
                 const get_result = await fn(input);
-                for (let i = 0; i < batched.resolvers.length; i++) {
+                for (let i = 0; i < entries.length; i++) {
                   try {
-                    batched.resolvers[i].resolve(get_result(input[i], i));
+                    const result = get_result(input[i], i);
+                    for (const resolver of entries[i].resolvers) {
+                      resolver.resolve(result);
+                    }
                   } catch (error2) {
-                    batched.resolvers[i].reject(error2);
+                    for (const resolver of entries[i].resolvers) {
+                      resolver.reject(error2);
+                    }
                   }
                 }
               }
             );
           } catch (error2) {
-            for (const resolver of batched.resolvers) {
-              resolver.reject(error2);
+            for (const entry2 of batched.values()) {
+              for (const resolver of entry2.resolvers) {
+                resolver.reject(error2);
+              }
             }
           }
         }, 0);
       });
-    };
-    const promise = get_response(__, arg, state, get_remote_function_result);
-    promise.catch(() => {
     });
-    promise.set = (value) => update_refresh_value(get_refresh_context(__, "set", arg), value);
-    promise.refresh = () => {
+  };
+  Object.defineProperty(wrapper, "__", { value: __ });
+  return wrapper;
+}
+function create_query_resource(__, arg, state, fn) {
+  let promise = null;
+  const get_promise = () => {
+    return promise ??= get_response(__, arg, state, fn);
+  };
+  return {
+    /** @type {Promise<any>['catch']} */
+    catch(onrejected) {
+      return get_promise().catch(onrejected);
+    },
+    current: void 0,
+    error: void 0,
+    /** @type {Promise<any>['finally']} */
+    finally(onfinally) {
+      return get_promise().finally(onfinally);
+    },
+    loading: true,
+    ready: false,
+    refresh() {
       const refresh_context = get_refresh_context(__, "refresh", arg);
       const is_immediate_refresh = !refresh_context.cache[refresh_context.cache_key];
-      const value = is_immediate_refresh ? promise : get_remote_function_result();
+      const value = is_immediate_refresh ? get_promise() : fn();
       return update_refresh_value(refresh_context, value, is_immediate_refresh);
-    };
-    promise.withOverride = () => {
+    },
+    run() {
+      if (!state.is_in_universal_load) {
+        throw new Error(
+          "On the server, .run() can only be called in universal `load` functions. Anywhere else, just await the query directly"
+        );
+      }
+      return get_response(__, arg, state, fn);
+    },
+    /** @param {any} value */
+    set(value) {
+      return update_refresh_value(get_refresh_context(__, "set", arg), value);
+    },
+    /** @type {Promise<any>['then']} */
+    then(onfulfilled, onrejected) {
+      return get_promise().then(onfulfilled, onrejected);
+    },
+    withOverride() {
       throw new Error(`Cannot call '${__.name}.withOverride()' on the server`);
-    };
-    return (
-      /** @type {RemoteQuery<Output>} */
-      promise
-    );
+    },
+    get [Symbol.toStringTag]() {
+      return "QueryResource";
+    }
   };
-  Object.defineProperty(wrapper, "__", { value: __ });
-  return wrapper;
 }
 Object.defineProperty(query, "batch", { value: batch, enumerable: true });
 function get_refresh_context(__, action, arg) {
   const { state } = get_request_store();
-  const { refreshes } = state;
+  const { refreshes } = state.remote;
   if (!refreshes) {
     const name = __.type === "query_batch" ? `query.batch '${__.name}'` : `query '${__.name}'`;
     throw new Error(
@@ -541,17 +608,114 @@ function get_refresh_context(__, action, arg) {
 function update_refresh_value({ __, refreshes, refreshes_key, cache, cache_key }, value, is_immediate_refresh = false) {
   const promise = Promise.resolve(value);
   if (!is_immediate_refresh) {
-    cache[cache_key] = promise;
+    cache[cache_key] = { serialize: true, data: promise };
   }
   if (__.id) {
     refreshes[refreshes_key] = promise;
   }
-  return promise.then(() => {
-  });
+  return promise.then(noop, noop);
+}
+function requested(query2, limit = Infinity) {
+  const { state } = get_request_store();
+  const internals = (
+    /** @type {RemoteQueryInternals | undefined} */
+    /** @type {any} */
+    query2.__
+  );
+  if (!internals || internals.type !== "query") {
+    throw new Error("requested(...) expects a query function created with query(...)");
+  }
+  const requested2 = state.remote.requested;
+  const payloads = requested2?.get(internals.id) ?? [];
+  const refreshes = state.remote.refreshes ??= {};
+  const [selected, skipped] = split_limit(payloads, limit);
+  const record_failure = (payload, error2) => {
+    const promise = Promise.reject(error2);
+    promise.catch(noop);
+    const key = create_remote_key(internals.id, payload);
+    refreshes[key] = promise;
+  };
+  for (const payload of skipped) {
+    record_failure(
+      payload,
+      new Error(
+        `Requested refresh was rejected because it exceeded requested(${internals.name}, ${limit}) limit`
+      )
+    );
+  }
+  return {
+    *[Symbol.iterator]() {
+      for (const payload of selected) {
+        try {
+          const parsed = parse_remote_arg(payload, state.transport);
+          const validated = internals.validate(parsed);
+          if (is_thenable(validated)) {
+            throw new Error(
+              // TODO improve
+              `requested(${internals.name}, ${limit}) cannot be used with synchronous iteration because the query validator is async. Use \`for await ... of\` instead`
+            );
+          }
+          yield mark_argument_validated(internals, state, validated);
+        } catch (error2) {
+          record_failure(payload, error2);
+          continue;
+        }
+      }
+    },
+    async *[Symbol.asyncIterator]() {
+      yield* race_all(selected, async (payload) => {
+        try {
+          const parsed = parse_remote_arg(payload, state.transport);
+          const validated = await internals.validate(parsed);
+          return mark_argument_validated(internals, state, validated);
+        } catch (error2) {
+          record_failure(payload, error2);
+          throw new Error(`Skipping ${internals.name}(${payload})`, { cause: error2 });
+        }
+      });
+    },
+    async refreshAll() {
+      for await (const arg of this) {
+        void query2(arg).refresh();
+      }
+    }
+  };
+}
+function split_limit(array, limit) {
+  if (limit === Infinity) {
+    return [array, []];
+  }
+  if (!Number.isInteger(limit) || limit < 0) {
+    throw new Error("Limit must be a non-negative integer or Infinity");
+  }
+  return [array.slice(0, limit), array.slice(limit)];
+}
+function is_thenable(value) {
+  return !!value && (typeof value === "object" || typeof value === "function") && "then" in value;
+}
+async function* race_all(array, fn) {
+  const pending = /* @__PURE__ */ new Set();
+  for (const value of array) {
+    const promise = Promise.resolve(fn(value)).then((result) => ({
+      promise,
+      value: result
+    }));
+    promise.catch(noop);
+    pending.add(promise);
+  }
+  while (pending.size > 0) {
+    try {
+      const { promise, value } = await Promise.race(pending);
+      pending.delete(promise);
+      yield value;
+    } catch {
+    }
+  }
 }
 export {
   command,
   form,
   prerender,
-  query
+  query,
+  requested
 };

package/web/.svelte-kit/tsconfig.json

@@ -37,7 +37,10 @@
 		"moduleResolution": "bundler",
 		"module": "esnext",
 		"noEmit": true,
-		"target": "esnext"
+		"target": "esnext",
+		"types": [
+			"node"
+		]
 	},
 	"include": [
 		"ambient.d.ts",