@celsoft/coordinator 0.0.0 → 0.1.0

package/build/chunk-BJTJS3XY.js

@@ -0,0 +1,338 @@
+import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);
+import {
+  resolveIcon
+} from "./chunk-M44JEFEH.js";
+import {
+  attr_class,
+  attributes,
+  bind_props,
+  clsx,
+  derived,
+  getContext,
+  html,
+  setContext
+} from "./chunk-KAYW2W7H.js";
+
+// build/server/chunks/Button.js
+function Icon($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { name, class: className = "" } = $$props;
+    const icon = derived(() => resolveIcon(name));
+    if (icon() && "component" in icon()) {
+      $$renderer2.push("<!--[0-->");
+      if (icon().component) {
+        $$renderer2.push("<!--[-->");
+        icon().component($$renderer2, {
+          class: ["sd-icon", className],
+          size: 16,
+          strokeWidth: 2,
+          "aria-hidden": "true"
+        });
+        $$renderer2.push("<!--]-->");
+      } else {
+        $$renderer2.push("<!--[!-->");
+        $$renderer2.push("<!--]-->");
+      }
+    } else $$renderer2.push(`<!--[-1--><svg${attr_class(clsx(["sd-icon", className]))} viewBox="0 0 24 24" aria-hidden="true">${html(icon() && "markup" in icon() ? icon().markup : "")}</svg>`);
+    $$renderer2.push(`<!--]-->`);
+  });
+}
+var timing = {
+  spinnerAfter: 400,
+  spinnerAtLeast: 300,
+  slowAfter: 1e4,
+  debounce: 500
+};
+var messages = {
+  working: "Working",
+  slow: "Still working",
+  saved: "Saved",
+  checking: "Checking the code",
+  failed: "That didn't work. Try again."
+};
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+var isThenable = (v) => v != null && typeof v.then === "function";
+var newKey = () => globalThis.crypto?.randomUUID?.() ?? Array.from(crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(16)), (b) => b.toString(16).padStart(2, "0")).join("");
+var region;
+function announce(text) {
+  if (typeof document === "undefined" || !text) return;
+  if (!region || !region.isConnected) {
+    region = document.createElement("div");
+    region.className = "sd-sr";
+    region.setAttribute("aria-live", "polite");
+    region.setAttribute("aria-atomic", "true");
+    region.dataset.sdAnnouncer = "";
+    document.body.append(region);
+  }
+  region.textContent = "";
+  setTimeout(() => region.textContent = text, 30);
+}
+var dev = () => globalThis.__SERVICE_DARK_DEV__ ?? false;
+var watch = {
+  until: 0,
+  name: "",
+  inside: false,
+  saw: false
+};
+var fetchWatched = false;
+function watchFetch() {
+  if (fetchWatched || typeof globalThis.fetch !== "function") return;
+  fetchWatched = true;
+  const original = globalThis.fetch;
+  globalThis.fetch = function(...args) {
+    if (watch.inside) watch.saw = true;
+    else if (performance.now() < watch.until) warnUnreturned(watch.name);
+    return original.apply(this, args);
+  };
+}
+function warnUnreturned(name) {
+  watch.until = 0;
+  console.warn(`Service Dark: ${name} started a request but its handler returned nothing, so nothing waited for it. Return the promise: () => save(), not () => { save(); }.`);
+}
+function call(fn, arg, name) {
+  if (!dev()) return fn(arg);
+  watchFetch();
+  watch.inside = true;
+  watch.saw = false;
+  let result;
+  try {
+    result = fn(arg);
+  } finally {
+    watch.inside = false;
+  }
+  if (!isThenable(result)) {
+    if (watch.saw) warnUnreturned(name);
+    else watch = {
+      until: performance.now() + 50,
+      name,
+      inside: false,
+      saw: false
+    };
+  }
+  return result;
+}
+var Pending = class {
+  /** True from the moment the wait starts: block repeats and edits. */
+  busy = false;
+  /** True once the wait passes timing.spinnerAfter: show the spinner. */
+  spinning = false;
+  /** True once the wait passes timing.slowAfter: say "Still working". */
+  slow = false;
+  /** The sentence from the last failed wait, until the next one starts. */
+  error = "";
+  #controller = null;
+  #key = null;
+  /**
+  * @param {object} [options]
+  * @param {string} [options.name] Names the component in dev warnings.
+  * @param {boolean} [options.abortable] Cancel and Escape may stop the wait instead of being blocked.
+  * @param {boolean} [options.speak] Announce "Working", "Still working" and errors. Default true.
+  */
+  constructor({ name = "A Service Dark handler", abortable = false, speak = true } = {}) {
+    this.name = name;
+    this.abortable = abortable;
+    this.speak = speak;
+  }
+  /**
+  * Run fn once; a call while busy is ignored.
+  * @param {(wait: { signal: AbortSignal, key: string }) => unknown} fn
+  * @returns {Promise<{ ok: boolean, error?: string, aborted?: boolean, skipped?: boolean, value?: unknown }>}
+  */
+  async run(fn) {
+    if (this.busy) return {
+      ok: false,
+      skipped: true
+    };
+    this.busy = true;
+    this.error = "";
+    const controller = new AbortController();
+    this.#controller = controller;
+    const key = this.#key ??= newKey();
+    let shownAt = 0;
+    const spin = setTimeout(() => {
+      this.spinning = true;
+      shownAt = performance.now();
+      if (this.speak) announce(messages.working);
+    }, timing.spinnerAfter);
+    const slow = setTimeout(() => {
+      this.slow = true;
+      if (this.speak) announce(messages.slow);
+    }, timing.slowAfter);
+    let outcome;
+    let unknown = false;
+    try {
+      const returned = call(fn, {
+        signal: controller.signal,
+        key
+      }, this.name);
+      outcome = isThenable(returned) ? await returned : void 0;
+    } catch (e) {
+      if (!controller.signal.aborted) {
+        unknown = true;
+        console.error(e);
+        outcome = messages.failed;
+      }
+    }
+    clearTimeout(spin);
+    clearTimeout(slow);
+    if (shownAt) {
+      const left = timing.spinnerAtLeast - (performance.now() - shownAt);
+      if (left > 0) await sleep(left);
+    }
+    this.busy = false;
+    this.spinning = false;
+    this.slow = false;
+    this.#controller = null;
+    if (!unknown) this.#key = null;
+    if (controller.signal.aborted) return {
+      ok: false,
+      aborted: true
+    };
+    if (outcome === false) return { ok: false };
+    if (typeof outcome === "string" && outcome) {
+      this.error = outcome;
+      if (this.speak) announce(outcome);
+      return {
+        ok: false,
+        error: outcome
+      };
+    }
+    return {
+      ok: true,
+      value: outcome
+    };
+  }
+  /** Stop waiting: the signal aborts, and the result is ignored. The server may still finish the request. */
+  abort() {
+    this.#controller?.abort();
+  }
+  /**
+  * For SvelteKit forms: <form method="POST" use:enhance={wait.enhance()} use:busy={wait.busy}>.
+  * A failure's `message` (from fail(400, { message })) becomes the error.
+  * @param {{ reset?: boolean, invalidateAll?: boolean }} [options] passed to update()
+  */
+  enhance(options) {
+    return ({ cancel, controller }) => {
+      if (this.busy) return cancel();
+      let finish;
+      const answered = new Promise((r) => finish = r);
+      this.run(({ signal }) => {
+        signal.addEventListener("abort", () => controller.abort());
+        return answered;
+      });
+      return async ({ result, update }) => {
+        await update(options);
+        if (result.type === "failure") finish(typeof result.data?.message === "string" ? result.data.message : messages.failed);
+        else if (result.type === "error") finish(messages.failed);
+        else finish();
+      };
+    };
+  }
+};
+var Latest = class {
+  pending;
+  #next = null;
+  /** @param {(result: Awaited<ReturnType<Pending["run"]>>) => void} onsettle called only for the latest send */
+  constructor(onsettle, name) {
+    this.pending = new Pending({
+      name,
+      speak: false
+    });
+    this.onsettle = onsettle;
+  }
+  /** @param {(wait: { signal: AbortSignal, key: string, seq: number }) => unknown} fn */
+  send(fn) {
+    const seq = nextSeq();
+    if (this.pending.busy) this.#next = {
+      fn,
+      seq
+    };
+    else this.#go({
+      fn,
+      seq
+    });
+  }
+  async #go({ fn, seq }) {
+    const result = await this.pending.run((wait) => fn({
+      ...wait,
+      seq
+    }));
+    const next = this.#next;
+    this.#next = null;
+    if (next) this.#go(next);
+    else this.onsettle?.(result);
+  }
+};
+var lastSeq = 0;
+function nextSeq() {
+  lastSeq = Math.max(lastSeq + 1, Math.floor((performance.timeOrigin + performance.now()) * 1e3));
+  return lastSeq;
+}
+var KEY = Symbol("sd-pending");
+function providePending(p) {
+  setContext(KEY, p);
+  return p;
+}
+function pendingContext() {
+  return getContext(KEY);
+}
+function buttonState({ own, form, submit, cancel }) {
+  if (submit && form) return {
+    blocked: form.busy,
+    spinning: form.spinning
+  };
+  return {
+    blocked: own.busy || !!form?.busy && !(cancel && form.abortable),
+    spinning: own.spinning
+  };
+}
+function Button($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { variant = "secondary", size = "md", icon, block = false, type = "button", cancel = false, error = "", onclick, class: className, children, $$slots, $$events, ...rest } = $$props;
+    const own = new Pending({ name: "A Button onclick" });
+    const form = pendingContext();
+    const state = derived(() => buttonState({
+      own,
+      form,
+      submit: type === "submit",
+      cancel
+    }));
+    $$renderer2.push(`<button${attributes({
+      type,
+      class: clsx([
+        "sd-btn",
+        `sd-btn-${variant}`,
+        size === "sm" && "sd-btn-sm",
+        block && "sd-btn-block",
+        state().spinning && "sd-btn-spinning",
+        !icon && "sd-btn-plain",
+        className
+      ]),
+      "aria-disabled": state().blocked ? "true" : void 0,
+      "aria-busy": state().spinning ? "true" : void 0,
+      ...rest
+    })}>`);
+    if (state().spinning) $$renderer2.push(`<!--[0--><span class="sd-spinner" aria-hidden="true"></span>`);
+    else if (icon) {
+      $$renderer2.push("<!--[1-->");
+      Icon($$renderer2, { name: icon });
+    } else $$renderer2.push("<!--[-1-->");
+    $$renderer2.push(`<!--]--> <span class="sd-btn-label">`);
+    children?.($$renderer2);
+    $$renderer2.push(`<!----></span></button>`);
+    bind_props($$props, { error });
+  });
+}
+
+export {
+  Icon,
+  timing,
+  messages,
+  Pending,
+  Latest,
+  nextSeq,
+  providePending,
+  pendingContext,
+  buttonState,
+  Button
+};

package/build/chunk-F2CNWJZM.js

@@ -0,0 +1,14 @@
+import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);
+
+// build/server/chunks/via.js
+import { AsyncLocalStorage } from "node:async_hooks";
+var PAGE = "page";
+var store = new AsyncLocalStorage();
+function throughVia(via, act) {
+  return store.run(via, act);
+}
+
+export {
+  PAGE,
+  throughVia
+};