@akashjs/runtime 0.1.0

package/dist/chunk-D3IR22HI.js

@@ -0,0 +1,662 @@
+// src/scheduler.ts
+var pendingRender = /* @__PURE__ */ new Set();
+var pendingUser = /* @__PURE__ */ new Set();
+var flushing = false;
+var batchDepth = 0;
+var flushScheduled = false;
+function flush() {
+  if (flushing) return;
+  flushing = true;
+  flushScheduled = false;
+  while (pendingRender.size > 0 || pendingUser.size > 0) {
+    if (pendingRender.size > 0) {
+      const queue = [...pendingRender].sort(byDepth);
+      pendingRender.clear();
+      for (const fx of queue) {
+        fx.run();
+      }
+    }
+    if (pendingUser.size > 0) {
+      const queue = [...pendingUser].sort(byDepth);
+      pendingUser.clear();
+      for (const fx of queue) {
+        fx.run();
+      }
+    }
+  }
+  flushing = false;
+}
+function scheduleEffect(fx) {
+  if (fx.isRender) {
+    pendingRender.add(fx);
+  } else {
+    pendingUser.add(fx);
+  }
+  if (batchDepth === 0 && !flushing && !flushScheduled) {
+    flushScheduled = true;
+    queueMicrotask(flush);
+  }
+}
+function batch(fn) {
+  batchDepth++;
+  try {
+    fn();
+  } finally {
+    batchDepth--;
+    if (batchDepth === 0) {
+      flush();
+    }
+  }
+}
+function byDepth(a, b) {
+  return (a.depth ?? 0) - (b.depth ?? 0);
+}
+function flushSync() {
+  flush();
+}
+
+// src/signals.ts
+var currentSubscriber = null;
+function signal(initialValue, options) {
+  const node = {
+    value: initialValue,
+    subscribers: /* @__PURE__ */ new Set(),
+    equals: options?.equals ?? Object.is
+  };
+  const read = () => {
+    trackSubscriber(node);
+    return node.value;
+  };
+  read.set = (value) => {
+    if (node.equals(node.value, value)) return;
+    node.value = value;
+    notifySubscribers(node);
+  };
+  read.update = (fn) => {
+    read.set(fn(node.value));
+  };
+  read.peek = () => node.value;
+  return read;
+}
+function computed(fn, options) {
+  const node = {
+    _tag: "computed",
+    fn,
+    value: void 0,
+    state: 1 /* Dirty */,
+    subscribers: /* @__PURE__ */ new Set(),
+    sources: /* @__PURE__ */ new Set(),
+    equals: options?.equals ?? Object.is
+  };
+  const read = () => {
+    if (currentSubscriber) {
+      node.subscribers.add(currentSubscriber);
+      if ("sources" in currentSubscriber) {
+        currentSubscriber.sources.add(node);
+      }
+    }
+    if (node.state !== 0 /* Clean */) {
+      recompute(node);
+    }
+    return node.value;
+  };
+  return read;
+}
+function recompute(node) {
+  for (const source of node.sources) {
+    source.subscribers.delete(node);
+  }
+  node.sources.clear();
+  const prevSubscriber = currentSubscriber;
+  currentSubscriber = node;
+  try {
+    const newValue = node.fn();
+    const changed = node.value === void 0 || !node.equals(node.value, newValue);
+    node.value = newValue;
+    node.state = 0 /* Clean */;
+    if (changed) {
+      notifySubscribers(node);
+    }
+  } finally {
+    currentSubscriber = prevSubscriber;
+  }
+}
+function effect(fn, options) {
+  const node = {
+    _tag: "effect",
+    fn,
+    cleanup: null,
+    sources: /* @__PURE__ */ new Set(),
+    disposed: false,
+    isRender: options?.render ?? false,
+    run() {
+      runEffect(node);
+    }
+  };
+  runEffect(node);
+  return () => {
+    node.disposed = true;
+    cleanupEffect(node);
+    for (const source of node.sources) {
+      source.subscribers.delete(node);
+    }
+    node.sources.clear();
+  };
+}
+function runEffect(node) {
+  if (node.disposed) return;
+  if (node.sources.size > 0) {
+    let anyChanged = false;
+    for (const source of node.sources) {
+      if ("_tag" in source && source._tag === "computed") {
+        if (source.state === 1 /* Dirty */) {
+          const oldValue = source.value;
+          recompute(source);
+          if (!source.equals(oldValue, source.value)) {
+            anyChanged = true;
+          }
+        }
+      } else {
+        anyChanged = true;
+      }
+    }
+    if (!anyChanged) return;
+  }
+  cleanupEffect(node);
+  for (const source of node.sources) {
+    source.subscribers.delete(node);
+  }
+  node.sources.clear();
+  const prevSubscriber = currentSubscriber;
+  currentSubscriber = node;
+  try {
+    const result = node.fn();
+    if (typeof result === "function") {
+      node.cleanup = result;
+    }
+  } finally {
+    currentSubscriber = prevSubscriber;
+  }
+}
+function cleanupEffect(node) {
+  if (node.cleanup) {
+    node.cleanup();
+    node.cleanup = null;
+  }
+}
+function untrack(fn) {
+  const prev = currentSubscriber;
+  currentSubscriber = null;
+  try {
+    return fn();
+  } finally {
+    currentSubscriber = prev;
+  }
+}
+function trackSubscriber(node) {
+  if (currentSubscriber) {
+    node.subscribers.add(currentSubscriber);
+    if ("sources" in currentSubscriber) {
+      currentSubscriber.sources.add(node);
+    }
+  }
+}
+function notifySubscribers(node) {
+  for (const sub of node.subscribers) {
+    if (sub._tag === "computed") {
+      sub.state = 1 /* Dirty */;
+      notifySubscribers(sub);
+    } else if (sub._tag === "effect") {
+      scheduleEffect(sub);
+    }
+  }
+}
+
+// src/errors.ts
+var errors = {
+  // --- Context errors (AK001x) ---
+  AK0010: {
+    code: "AK0010",
+    message: "provide() called outside of component setup.",
+    hint: "provide() must be called inside defineComponent()."
+  },
+  AK0012: {
+    code: "AK0012",
+    message: "inject() called outside of component setup.",
+    hint: "inject() must be called inside defineComponent()."
+  },
+  AK0013: {
+    code: "AK0013",
+    message: "No provider found for injected context.",
+    hint: "Make sure an ancestor component calls provide() with this key."
+  },
+  // --- Lifecycle errors (AK002x) ---
+  AK0020: {
+    code: "AK0020",
+    message: "onMount() called outside of component setup.",
+    hint: "onMount() must be called inside defineComponent()."
+  },
+  AK0021: {
+    code: "AK0021",
+    message: "onUnmount() called outside of component setup.",
+    hint: "onUnmount() must be called inside defineComponent()."
+  },
+  AK0022: {
+    code: "AK0022",
+    message: "onError() called outside of component setup.",
+    hint: "onError() must be called inside defineComponent()."
+  },
+  // --- Signal errors (AK003x) ---
+  AK0030: {
+    code: "AK0030",
+    message: "Circular dependency detected in computed signal.",
+    hint: "A computed signal is reading itself, directly or via other computeds."
+  },
+  AK0031: {
+    code: "AK0031",
+    message: "Signal set() called during computation.",
+    hint: "Do not set signals inside computed() or during effect execution. Use batch() or set signals in event handlers."
+  },
+  // --- Component errors (AK004x) ---
+  AK0040: {
+    code: "AK0040",
+    message: "Component setup must return a render function.",
+    hint: "The function passed to defineComponent() must return () => AkashNode."
+  },
+  AK0041: {
+    code: "AK0041",
+    message: "Required prop is missing.",
+    hint: "Check that the parent component is passing all required props."
+  },
+  // --- Router errors (AK005x) ---
+  AK0050: {
+    code: "AK0050",
+    message: "useRoute() called outside of router context.",
+    hint: "Make sure your component is rendered inside a router provider."
+  },
+  AK0051: {
+    code: "AK0051",
+    message: "No route matched the current URL.",
+    hint: "Add a catch-all route ([...rest]) to handle unmatched paths."
+  },
+  AK0052: {
+    code: "AK0052",
+    message: "Route guard threw an error.",
+    hint: "Check the guard function for unhandled exceptions."
+  },
+  // --- Form errors (AK006x) ---
+  AK0060: {
+    code: "AK0060",
+    message: "Form submitted while invalid.",
+    hint: "The submit handler was not called because validation failed. Check form.errors()."
+  },
+  AK0061: {
+    code: "AK0061",
+    message: "Async validator timed out.",
+    hint: "The async validator did not resolve within the expected time. Check your async validation logic."
+  },
+  // --- HTTP errors (AK007x) ---
+  AK0070: {
+    code: "AK0070",
+    message: "HTTP request failed.",
+    hint: "Check the server response status and network connectivity."
+  },
+  AK0071: {
+    code: "AK0071",
+    message: "createResource() fetcher threw an error.",
+    hint: "Check the fetcher function passed to createResource()."
+  }
+};
+var DOC_BASE = "https://akashjs.dev/errors";
+function formatError(code, context) {
+  const def = errors[code];
+  if (!def) {
+    return `[AkashJS ${code}] Unknown error code.`;
+  }
+  let msg = `[AkashJS ${code}] ${def.message}`;
+  if (context) {
+    msg += `
+  ${context}`;
+  }
+  msg += `
+  ${def.hint}`;
+  msg += `
+  See: ${DOC_BASE}/${code}`;
+  return msg;
+}
+function akashError(code, context) {
+  return new Error(formatError(code, context));
+}
+function getErrorDef(code) {
+  return errors[code];
+}
+function getAllErrorCodes() {
+  return Object.keys(errors);
+}
+
+// src/context.ts
+var CONTEXT_BRAND = /* @__PURE__ */ Symbol("akash.context");
+var currentScope = null;
+function pushScope(parent = currentScope) {
+  const scope = { values: /* @__PURE__ */ new Map(), parent };
+  currentScope = scope;
+  return scope;
+}
+function popScope(scope) {
+  currentScope = scope.parent;
+}
+function getCurrentScope() {
+  return currentScope;
+}
+function createContext(defaultValue) {
+  return {
+    [CONTEXT_BRAND]: true,
+    _type: void 0,
+    defaultValue,
+    id: /* @__PURE__ */ Symbol("context")
+  };
+}
+function provide(key, value) {
+  if (!currentScope) {
+    throw akashError("AK0010");
+  }
+  currentScope.values.set(key.id, value);
+}
+function inject(key, fallback) {
+  if (!currentScope) {
+    throw akashError("AK0012");
+  }
+  let scope = currentScope;
+  while (scope) {
+    if (scope.values.has(key.id)) {
+      return scope.values.get(key.id);
+    }
+    scope = scope.parent;
+  }
+  if (fallback !== void 0) return fallback;
+  if (key.defaultValue !== void 0) return key.defaultValue;
+  throw akashError("AK0013");
+}
+
+// src/dom.ts
+function createElement(tag, attrs) {
+  const el = document.createElement(tag);
+  if (attrs) {
+    for (const [key, value] of Object.entries(attrs)) {
+      setProperty(el, key, value);
+    }
+  }
+  return el;
+}
+function createText(value) {
+  return document.createTextNode(value);
+}
+function cloneTemplate(html) {
+  const template = document.createElement("template");
+  template.innerHTML = html;
+  return template.content.cloneNode(true);
+}
+function setProperty(el, key, value) {
+  if (key === "class" || key === "className") {
+    el.className = value;
+  } else if (key === "style" && typeof value === "object" && value !== null) {
+    Object.assign(el.style, value);
+  } else if (key === "innerHTML") {
+    el.innerHTML = value;
+  } else if (key === "ref") ; else if (key.startsWith("on")) {
+    const event = key.slice(2).toLowerCase();
+    el.addEventListener(event, value);
+  } else if (key in el) {
+    el[key] = value;
+  } else if (value === false || value == null) {
+    el.removeAttribute(key);
+  } else {
+    el.setAttribute(key, value === true ? "" : String(value));
+  }
+}
+function bindText(node, fn) {
+  return effect(
+    () => {
+      node.textContent = String(fn());
+    },
+    { render: true }
+  );
+}
+function bindProperty(el, key, fn) {
+  return effect(
+    () => {
+      setProperty(el, key, fn());
+    },
+    { render: true }
+  );
+}
+function bindVisible(el, fn) {
+  return effect(
+    () => {
+      el.style.display = fn() ? "" : "none";
+    },
+    { render: true }
+  );
+}
+function createAnchor(label = "") {
+  return document.createComment(label);
+}
+function renderConditional(parent, anchor, condition, trueBranch, falseBranch) {
+  let current = null;
+  const dispose = effect(
+    () => {
+      const value = condition();
+      if (current) {
+        for (const node of current.nodes) {
+          parent.removeChild(node);
+        }
+        current.dispose?.();
+        current = null;
+      }
+      const branch = value ? trueBranch : falseBranch;
+      if (branch) {
+        const fragment = branch();
+        const nodes = fragment instanceof DocumentFragment ? Array.from(fragment.childNodes) : [fragment];
+        for (const node of nodes) {
+          parent.insertBefore(node, anchor);
+        }
+        current = { nodes, dispose: null };
+      }
+    },
+    { render: true }
+  );
+  return () => {
+    dispose();
+    if (current) {
+      for (const node of current.nodes) {
+        if (node.parentNode) node.parentNode.removeChild(node);
+      }
+      current.dispose?.();
+    }
+  };
+}
+function renderList(parent, anchor, items, keyFn, renderItem) {
+  let currentItems = [];
+  const dispose = effect(
+    () => {
+      const newData = items();
+      const newItems = [];
+      const oldMap = /* @__PURE__ */ new Map();
+      for (const item of currentItems) {
+        oldMap.set(item.key, item);
+      }
+      for (let i = 0; i < newData.length; i++) {
+        const data = newData[i];
+        const key = keyFn(data, i);
+        const existing = oldMap.get(key);
+        if (existing) {
+          oldMap.delete(key);
+          existing.value = data;
+          newItems.push(existing);
+        } else {
+          const fragment = renderItem(data, i);
+          const nodes = fragment instanceof DocumentFragment ? Array.from(fragment.childNodes) : [fragment];
+          newItems.push({ key, value: data, nodes, dispose: null });
+        }
+      }
+      for (const item of oldMap.values()) {
+        for (const node of item.nodes) {
+          if (node.parentNode) node.parentNode.removeChild(node);
+        }
+        item.dispose?.();
+      }
+      for (const item of newItems) {
+        for (const node of item.nodes) {
+          parent.insertBefore(node, anchor);
+        }
+      }
+      currentItems = newItems;
+    },
+    { render: true }
+  );
+  return () => {
+    dispose();
+    for (const item of currentItems) {
+      for (const node of item.nodes) {
+        if (node.parentNode) node.parentNode.removeChild(node);
+      }
+      item.dispose?.();
+    }
+    currentItems = [];
+  };
+}
+function Show(props) {
+  const anchor = createAnchor("show");
+  const container = document.createDocumentFragment();
+  container.appendChild(anchor);
+  renderConditional(
+    container,
+    anchor,
+    () => !!props.when,
+    () => nodeToDOM(props.children(props.when)),
+    props.fallback ? () => nodeToDOM(props.fallback()) : void 0
+  );
+  return container;
+}
+function For(props) {
+  const anchor = createAnchor("for");
+  const container = document.createDocumentFragment();
+  container.appendChild(anchor);
+  renderList(
+    container,
+    anchor,
+    () => props.each,
+    props.key,
+    (item, index) => nodeToDOM(props.children(item, index))
+  );
+  return container;
+}
+function nodeToDOM(node) {
+  if (node == null || typeof node === "boolean") {
+    return document.createTextNode("");
+  }
+  if (typeof node === "string" || typeof node === "number") {
+    return document.createTextNode(String(node));
+  }
+  if (node instanceof Node) {
+    return node;
+  }
+  if (Array.isArray(node)) {
+    const fragment = document.createDocumentFragment();
+    for (const child of node) {
+      fragment.appendChild(nodeToDOM(child));
+    }
+    return fragment;
+  }
+  return document.createTextNode(String(node));
+}
+function insert(parent, node, anchor) {
+  const domNode = nodeToDOM(node);
+  if (anchor) {
+    parent.insertBefore(domNode, anchor);
+  } else {
+    parent.appendChild(domNode);
+  }
+}
+
+// src/component.ts
+var currentHooks = null;
+function onMount(fn) {
+  if (!currentHooks) {
+    throw akashError("AK0020");
+  }
+  currentHooks.mount.push(fn);
+}
+function onUnmount(fn) {
+  if (!currentHooks) {
+    throw akashError("AK0021");
+  }
+  currentHooks.unmount.push(fn);
+}
+function onError(fn) {
+  if (!currentHooks) {
+    throw akashError("AK0022");
+  }
+  currentHooks.error.push(fn);
+}
+function ref() {
+  return { current: void 0 };
+}
+function defineComponent(setup) {
+  const component = (rawProps) => {
+    const { children: childrenProp, ...restProps } = rawProps ?? {};
+    const props = restProps;
+    const childrenFn = typeof childrenProp === "function" ? childrenProp : () => childrenProp ?? null;
+    const ctx = {
+      props,
+      children: childrenFn
+    };
+    const hooks = { mount: [], unmount: [], error: [] };
+    const prevHooks = currentHooks;
+    currentHooks = hooks;
+    const parentScope = getCurrentScope();
+    const scope = pushScope(parentScope);
+    let renderFn;
+    let domNode;
+    try {
+      renderFn = setup(ctx);
+      const rendered = renderFn();
+      domNode = nodeToDOM(rendered);
+    } catch (err) {
+      popScope(scope);
+      currentHooks = prevHooks;
+      if (hooks.error.length > 0) {
+        for (const handler of hooks.error) {
+          handler(err instanceof Error ? err : new Error(String(err)));
+        }
+        return document.createComment("error");
+      }
+      throw err;
+    }
+    popScope(scope);
+    currentHooks = prevHooks;
+    if (hooks.mount.length > 0) {
+      queueMicrotask(() => {
+        for (const mountFn of hooks.mount) {
+          try {
+            const cleanup = mountFn();
+            if (typeof cleanup === "function") {
+              hooks.unmount.push(cleanup);
+            }
+          } catch (err) {
+            for (const handler of hooks.error) {
+              handler(err instanceof Error ? err : new Error(String(err)));
+            }
+          }
+        }
+      });
+    }
+    return domNode;
+  };
+  component._akash = true;
+  return component;
+}
+
+export { For, Show, akashError, batch, bindProperty, bindText, bindVisible, cloneTemplate, computed, createContext, createElement, createText, defineComponent, effect, flushSync, formatError, getAllErrorCodes, getErrorDef, inject, insert, nodeToDOM, onError, onMount, onUnmount, provide, ref, renderConditional, renderList, setProperty, signal, untrack };
+//# sourceMappingURL=chunk-D3IR22HI.js.map
+//# sourceMappingURL=chunk-D3IR22HI.js.map