@askrjs/askr 0.0.1 → 0.0.3

package/dist/chunk-OFW6DFBM.js

@@ -0,0 +1,716 @@
+import {
+  createComponentInstance,
+  getCurrentComponentInstance,
+  logger,
+  route_exports,
+  setCurrentComponentInstance
+} from "./chunk-2ONGHQ7Z.js";
+import {
+  ELEMENT_TYPE,
+  Fragment
+} from "./chunk-JHOGWTAW.js";
+
+// src/jsx/utils.ts
+function isElement(value) {
+  return typeof value === "object" && value !== null && value.$$typeof === ELEMENT_TYPE;
+}
+function cloneElement(element, props) {
+  return {
+    ...element,
+    props: { ...element.props, ...props }
+  };
+}
+
+// src/foundations/portal.tsx
+function definePortal() {
+  if (typeof createPortalSlot !== "function") {
+    let HostFallback2 = function() {
+      hosts = hosts.filter((h) => h.mounted !== false);
+      const inst = getCurrentComponentInstance();
+      if (inst && !hosts.includes(inst)) hosts.push(inst);
+      const owner = hosts.find((h) => h.mounted === true) || null;
+      const mountedHosts = hosts.filter((h) => h.mounted === true);
+      if (mountedHosts.length > 1) {
+        logger.warn(
+          "[Portal] multiple hosts are mounted for same portal; first mounted host will be owner"
+        );
+      }
+      if (inst && owner && owner !== inst) {
+        logger.debug(
+          "[Portal] non-owner reader detected; only owner renders portal content"
+        );
+      }
+      if (process.env.NODE_ENV !== "production") {
+        const ns = globalThis.__ASKR__ || (globalThis.__ASKR__ = {});
+        ns.__PORTAL_READS = (ns.__PORTAL_READS || 0) + 1;
+      }
+      if (process.env.NODE_ENV !== "production" && inst && owner && inst === owner) {
+        logger.debug("[Portal] owner read ->", inst.id, "pending=", pending);
+        const ns = globalThis.__ASKR__ || (globalThis.__ASKR__ = {});
+        ns.__PORTAL_HOST_ATTACHED = !!(inst && inst.target);
+        ns.__PORTAL_HOST_ID = inst ? inst.id : void 0;
+      }
+      return inst === owner ? pending : void 0;
+    };
+    var HostFallback = HostFallback2;
+    let hosts = [];
+    let pending;
+    HostFallback2.render = function RenderFallback(props) {
+      hosts = hosts.filter((h) => h.mounted !== false);
+      const owner = hosts.find((h) => h.mounted === true) || null;
+      if (!owner) {
+        logger.debug(
+          "[Portal] fallback.write dropped -> no owner or not mounted",
+          props?.children
+        );
+        return null;
+      }
+      pending = props.children;
+      logger.debug("[Portal] fallback.write ->", pending, "owner=", owner.id);
+      if (process.env.NODE_ENV !== "production") {
+        const ns = globalThis.__ASKR__ || (globalThis.__ASKR__ = {});
+        ns.__PORTAL_WRITES = (ns.__PORTAL_WRITES || 0) + 1;
+      }
+      if (owner && owner.notifyUpdate) {
+        if (process.env.NODE_ENV !== "production")
+          logger.debug(
+            "[Portal] fallback.write notify ->",
+            owner.id,
+            !!owner.notifyUpdate
+          );
+        owner.notifyUpdate();
+      }
+      return null;
+    };
+    return HostFallback2;
+  }
+  const slot = createPortalSlot();
+  function PortalHost() {
+    return slot.read();
+  }
+  PortalHost.render = function PortalRender(props) {
+    logger.debug("[Portal] write ->", props?.children);
+    if (process.env.NODE_ENV !== "production") {
+      const ns = globalThis.__ASKR__ || (globalThis.__ASKR__ = {});
+      ns.__PORTAL_WRITES = (ns.__PORTAL_WRITES || 0) + 1;
+    }
+    slot.write(props.children);
+    return null;
+  };
+  return PortalHost;
+}
+var _defaultPortal;
+var _defaultPortalIsFallback = false;
+function _resetDefaultPortal() {
+  _defaultPortal = void 0;
+  _defaultPortalIsFallback = false;
+}
+function ensureDefaultPortal() {
+  logger.debug(
+    "[DefaultPortal] ensureDefaultPortal _defaultPortalIsFallback=",
+    _defaultPortalIsFallback,
+    "createPortalSlot=",
+    typeof createPortalSlot === "function"
+  );
+  if (!_defaultPortal) {
+    if (typeof createPortalSlot === "function") {
+      _defaultPortal = definePortal();
+      _defaultPortalIsFallback = false;
+      logger.debug("[DefaultPortal] created real portal");
+    } else {
+      _defaultPortal = definePortal();
+      _defaultPortalIsFallback = true;
+      logger.debug("[DefaultPortal] created fallback portal");
+    }
+    return _defaultPortal;
+  }
+  if (_defaultPortalIsFallback && typeof createPortalSlot === "function") {
+    const real = definePortal();
+    _defaultPortal = real;
+    _defaultPortalIsFallback = false;
+  }
+  if (!_defaultPortalIsFallback && typeof createPortalSlot !== "function") {
+    const fallback = definePortal();
+    _defaultPortal = fallback;
+    _defaultPortalIsFallback = true;
+    logger.debug("[DefaultPortal] reverted to fallback portal");
+  }
+  return _defaultPortal;
+}
+var DefaultPortal = (() => {
+  function Host() {
+    const v = ensureDefaultPortal()();
+    return v === void 0 ? null : v;
+  }
+  Host.render = function Render(props) {
+    ensureDefaultPortal().render(props);
+    return null;
+  };
+  return Host;
+})();
+
+// src/ssr/errors.ts
+var SSRDataMissingError = class _SSRDataMissingError extends Error {
+  constructor(message = "Server-side rendering requires all data to be available synchronously. This component attempted to use async data during SSR.") {
+    super(message);
+    this.code = "SSR_DATA_MISSING";
+    this.name = "SSRDataMissingError";
+    Object.setPrototypeOf(this, _SSRDataMissingError.prototype);
+  }
+};
+
+// src/ssr/context.ts
+var current = null;
+function withSSRContext(ctx, fn) {
+  const prev = current;
+  current = ctx;
+  try {
+    return fn();
+  } finally {
+    current = prev;
+  }
+}
+function createRenderContext(seed = 12345) {
+  return { seed };
+}
+var currentSSRContext = null;
+function getCurrentSSRContext() {
+  return currentSSRContext;
+}
+function runWithSSRContext(ctx, fn) {
+  const prev = currentSSRContext;
+  currentSSRContext = ctx;
+  try {
+    return fn();
+  } finally {
+    currentSSRContext = prev;
+  }
+}
+function throwSSRDataMissing() {
+  throw new SSRDataMissingError();
+}
+
+// src/ssr/escape.ts
+var VOID_ELEMENTS = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+var escapeCache = /* @__PURE__ */ new Map();
+var MAX_CACHE_SIZE = 256;
+function escapeText(text) {
+  const useCache = text.length <= 64;
+  if (useCache) {
+    const cached = escapeCache.get(text);
+    if (cached !== void 0) return cached;
+  }
+  const str = String(text);
+  if (!str.includes("&") && !str.includes("<") && !str.includes(">")) {
+    if (useCache && escapeCache.size < MAX_CACHE_SIZE) {
+      escapeCache.set(text, str);
+    }
+    return str;
+  }
+  const result = str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  if (useCache && escapeCache.size < MAX_CACHE_SIZE) {
+    escapeCache.set(text, result);
+  }
+  return result;
+}
+function escapeAttr(value) {
+  const str = String(value);
+  if (!str.includes("&") && !str.includes('"') && !str.includes("'") && !str.includes("<") && !str.includes(">")) {
+    return str;
+  }
+  return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeCssValue(value) {
+  const str = String(value);
+  if (/(?:url|expression|javascript)\s*\(/i.test(str)) {
+    return "";
+  }
+  return str.replace(/[{}<>\\]/g, "");
+}
+function styleObjToCss(value) {
+  if (!value || typeof value !== "object") return null;
+  const entries = Object.entries(value);
+  if (entries.length === 0) return "";
+  let out = "";
+  for (const [k, v] of entries) {
+    if (v === null || v === void 0 || v === false) continue;
+    const prop = k.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+    const safeValue = escapeCssValue(String(v));
+    if (safeValue) {
+      out += `${prop}:${safeValue};`;
+    }
+  }
+  return out;
+}
+
+// src/ssr/attrs.ts
+function renderAttrs(props, opts) {
+  if (!props || typeof props !== "object") {
+    return opts?.returnDangerousHtml ? { attrs: "" } : "";
+  }
+  let result = "";
+  let dangerousHtml;
+  for (const [key, value] of Object.entries(props)) {
+    if (key === "children") continue;
+    if (key === "dangerouslySetInnerHTML") {
+      if (value && typeof value === "object" && "__html" in value) {
+        dangerousHtml = String(value.__html);
+      }
+      continue;
+    }
+    if (key.length >= 3 && key[0] === "o" && key[1] === "n" && key[2] >= "A" && key[2] <= "Z") {
+      continue;
+    }
+    if (key.startsWith("_")) continue;
+    const attrName = key === "class" || key === "className" ? "class" : key;
+    if (attrName === "style") {
+      const css = typeof value === "string" ? value : styleObjToCss(value);
+      if (css === null || css === "") continue;
+      result += ` style="${escapeAttr(css)}"`;
+      continue;
+    }
+    if (value === true) {
+      result += ` ${attrName}`;
+    } else if (value === false || value === null || value === void 0) {
+      continue;
+    } else {
+      result += ` ${attrName}="${escapeAttr(String(value))}"`;
+    }
+  }
+  if (opts?.returnDangerousHtml) {
+    return { attrs: result, dangerousHtml };
+  }
+  return result;
+}
+
+// src/ssr/sink.ts
+var StringSink = class {
+  constructor() {
+    this.chunks = [];
+  }
+  write(html) {
+    if (html) this.chunks.push(html);
+  }
+  end() {
+  }
+  toString() {
+    return this.chunks.join("");
+  }
+};
+var StreamSink = class {
+  constructor(onChunk, onComplete) {
+    this.onChunk = onChunk;
+    this.onComplete = onComplete;
+  }
+  write(html) {
+    if (html) this.onChunk(html);
+  }
+  end() {
+    this.onComplete();
+  }
+};
+
+// src/ssr/stream-render.ts
+function isVNodeLike(x) {
+  return !!x && typeof x === "object" && "type" in x;
+}
+function normalizeChildren(node) {
+  const n = node;
+  const direct = Array.isArray(n?.children) ? n?.children : null;
+  const fromProps = n?.props?.children;
+  const raw = direct ?? fromProps;
+  if (raw === null || raw === void 0 || raw === false) return [];
+  if (Array.isArray(raw)) return raw;
+  return [raw];
+}
+function renderChildrenToSink(children, sink, ctx) {
+  for (const c of children)
+    renderNodeToSink(
+      c,
+      sink,
+      ctx
+    );
+}
+function isPromiseLike(x) {
+  if (!x || typeof x !== "object") return false;
+  const then = x.then;
+  return typeof then === "function";
+}
+function executeComponent(type, props, ctx) {
+  const res = type(props ?? {}, { signal: ctx.signal });
+  if (isPromiseLike(res)) {
+    throwSSRDataMissing();
+  }
+  return res;
+}
+function renderNodeToSink(node, sink, ctx) {
+  if (node === null || node === void 0) return;
+  if (typeof node === "string") {
+    sink.write(escapeText(node));
+    return;
+  }
+  if (typeof node === "number") {
+    sink.write(escapeText(String(node)));
+    return;
+  }
+  if (!isVNodeLike(node)) return;
+  const { type, props } = node;
+  if (typeof type === "symbol" && (type === Fragment || String(type) === "Symbol(Fragment)")) {
+    const children = normalizeChildren(node);
+    renderChildrenToSink(children, sink, ctx);
+    return;
+  }
+  if (typeof type === "function") {
+    const out = withSSRContext(
+      ctx,
+      () => executeComponent(type, props, ctx)
+    );
+    renderNodeToSink(
+      out,
+      sink,
+      ctx
+    );
+    return;
+  }
+  const tag = String(type);
+  const { attrs, dangerousHtml } = renderAttrs(props, {
+    returnDangerousHtml: true
+  });
+  if (VOID_ELEMENTS.has(tag)) {
+    sink.write(`<${tag}${attrs} />`);
+    return;
+  }
+  sink.write(`<${tag}${attrs}>`);
+  if (dangerousHtml !== void 0) {
+    sink.write(dangerousHtml);
+  } else {
+    const children = normalizeChildren(node);
+    renderChildrenToSink(children, sink, ctx);
+  }
+  sink.write(`</${tag}>`);
+}
+
+// src/ssr/render-keys.ts
+var keyCounter = 0;
+var currentRenderData = null;
+function getCurrentRenderData() {
+  return currentRenderData;
+}
+function resetKeyCounter() {
+  keyCounter = 0;
+}
+function getNextKey() {
+  return `r:${keyCounter++}`;
+}
+function startRenderPhase(data) {
+  currentRenderData = data ?? null;
+  resetKeyCounter();
+}
+function stopRenderPhase() {
+  currentRenderData = null;
+  resetKeyCounter();
+}
+var PREPASS_REMOVED_MSG = "SSR collection/prepass is removed: SSR is strictly synchronous";
+async function resolvePlan(_plan) {
+  throw new Error(
+    `${PREPASS_REMOVED_MSG}; async resource plans are not supported`
+  );
+}
+function collectResources(_opts) {
+  throw new Error(`${PREPASS_REMOVED_MSG}; collectResources is disabled`);
+}
+var resolveResources = resolvePlan;
+
+// src/ssr/index.ts
+var __ssrGuardStack = [];
+function pushSSRStrictPurityGuard() {
+  if (process.env.NODE_ENV === "production") return;
+  __ssrGuardStack.push({
+    random: Reflect.get(Math, "random"),
+    now: Reflect.get(Date, "now")
+  });
+  Reflect.set(Math, "random", () => {
+    throw new Error(
+      "SSR Strict Purity: Math.random is not allowed during synchronous SSR. Use the provided `ssr` context RNG instead."
+    );
+  });
+  Reflect.set(Date, "now", () => {
+    throw new Error(
+      "SSR Strict Purity: Date.now is not allowed during synchronous SSR. Pass timestamps explicitly or use deterministic helpers."
+    );
+  });
+}
+function popSSRStrictPurityGuard() {
+  if (process.env.NODE_ENV === "production") return;
+  const prev = __ssrGuardStack.pop();
+  if (prev) {
+    Reflect.set(Math, "random", prev.random);
+    Reflect.set(Date, "now", prev.now);
+  }
+}
+function renderChildSync(child, ctx) {
+  if (typeof child === "string") return escapeText(child);
+  if (typeof child === "number") return escapeText(String(child));
+  if (child === null || child === void 0 || child === false) return "";
+  if (typeof child === "object" && child !== null && "type" in child) {
+    return renderNodeSync(child, ctx);
+  }
+  return "";
+}
+function renderChildrenSync(children, ctx) {
+  if (!children || !Array.isArray(children) || children.length === 0) return "";
+  let result = "";
+  for (const child of children) result += renderChildSync(child, ctx);
+  return result;
+}
+function renderNodeSync(node, ctx) {
+  const { type, props } = node;
+  if (process.env.NODE_ENV !== "production") {
+    try {
+      logger.warn("[SSR] renderNodeSync type:", typeof type, type);
+    } catch {
+    }
+  }
+  if (typeof type === "function") {
+    const result = executeComponentSync(type, props, ctx);
+    if (result instanceof Promise) {
+      throwSSRDataMissing();
+    }
+    return renderNodeSync(result, ctx);
+  }
+  if (typeof type === "symbol") {
+    if (type === Fragment) {
+      const childrenArr = Array.isArray(node.children) ? node.children : Array.isArray(props?.children) ? props?.children : void 0;
+      if (process.env.NODE_ENV !== "production") {
+        try {
+          logger.warn("[SSR] fragment children length:", childrenArr?.length);
+        } catch {
+        }
+      }
+      return renderChildrenSync(childrenArr, ctx);
+    }
+    throw new Error(
+      `renderNodeSync: unsupported VNode symbol type: ${String(type)}`
+    );
+  }
+  const typeStr = type;
+  if (VOID_ELEMENTS.has(typeStr)) {
+    const attrs2 = renderAttrs(props);
+    return `<${typeStr}${attrs2} />`;
+  }
+  const { attrs, dangerousHtml } = renderAttrs(props, {
+    returnDangerousHtml: true
+  });
+  if (dangerousHtml !== void 0) {
+    return `<${typeStr}${attrs}>${dangerousHtml}</${typeStr}>`;
+  }
+  const children = node.children;
+  const childrenHtml = renderChildrenSync(children, ctx);
+  return `<${typeStr}${attrs}>${childrenHtml}</${typeStr}>`;
+}
+function executeComponentSync(component, props, ctx) {
+  try {
+    if (process.env.NODE_ENV !== "production") {
+      pushSSRStrictPurityGuard();
+    }
+    const prev = getCurrentComponentInstance();
+    const temp = createComponentInstance(
+      "ssr-temp",
+      component,
+      props || {},
+      null
+    );
+    temp.ssr = true;
+    setCurrentComponentInstance(temp);
+    try {
+      return runWithSSRContext(ctx, () => {
+        const result = component(props || {}, { ssr: ctx });
+        if (result instanceof Promise) {
+          throwSSRDataMissing();
+        }
+        if (typeof result === "string" || typeof result === "number" || typeof result === "boolean" || result === null || result === void 0) {
+          const inner = result === null || result === void 0 || result === false ? "" : String(result);
+          return {
+            $$typeof: ELEMENT_TYPE,
+            type: Fragment,
+            props: { children: inner ? [inner] : [] }
+          };
+        }
+        return result;
+      });
+    } finally {
+      setCurrentComponentInstance(prev);
+    }
+  } finally {
+    if (process.env.NODE_ENV !== "production") popSSRStrictPurityGuard();
+  }
+}
+function renderToStringSync(component, props, options) {
+  const seed = options?.seed ?? 12345;
+  const ctx = createRenderContext(seed);
+  startRenderPhase(options?.data ?? null);
+  try {
+    const wrapped = (p, c) => {
+      const out = component(p ?? {}, c);
+      const portalVNode = {
+        $$typeof: ELEMENT_TYPE,
+        type: DefaultPortal,
+        props: {},
+        key: "__default_portal"
+      };
+      if (out == null) {
+        return {
+          $$typeof: ELEMENT_TYPE,
+          type: Fragment,
+          props: { children: [portalVNode] }
+        };
+      }
+      return {
+        $$typeof: ELEMENT_TYPE,
+        type: Fragment,
+        props: { children: [out, portalVNode] }
+      };
+    };
+    const node = executeComponentSync(wrapped, props || {}, ctx);
+    if (!node) {
+      throw new Error("renderToStringSync: wrapped component returned empty");
+    }
+    return renderNodeSync(node, ctx);
+  } finally {
+    stopRenderPhase();
+  }
+}
+function renderToStringSyncForUrl(opts) {
+  const { url, routes, options } = opts;
+  const {
+    clearRoutes,
+    route,
+    setServerLocation,
+    lockRouteRegistration,
+    resolveRoute
+  } = route_exports;
+  clearRoutes();
+  for (const r of routes) {
+    route(r.path, r.handler, r.namespace);
+  }
+  setServerLocation(url);
+  if (process.env.NODE_ENV === "production") lockRouteRegistration();
+  const resolved = resolveRoute(url);
+  if (!resolved)
+    throw new Error(`renderToStringSync: no route found for url: ${url}`);
+  const seed = options?.seed ?? 12345;
+  const ctx = createRenderContext(seed);
+  startRenderPhase(options?.data ?? null);
+  try {
+    const wrapped = (p, c) => {
+      const out = resolved.handler(p ?? {}, c);
+      const portalVNode = {
+        $$typeof: ELEMENT_TYPE,
+        type: DefaultPortal,
+        props: {},
+        key: "__default_portal"
+      };
+      if (out == null) {
+        return {
+          $$typeof: ELEMENT_TYPE,
+          type: Fragment,
+          props: { children: [portalVNode] }
+        };
+      }
+      return {
+        $$typeof: ELEMENT_TYPE,
+        type: Fragment,
+        props: { children: [out, portalVNode] }
+      };
+    };
+    const node = executeComponentSync(wrapped, resolved.params || {}, ctx);
+    return renderNodeSync(node, ctx);
+  } finally {
+    stopRenderPhase();
+  }
+}
+function renderToString(arg) {
+  if (typeof arg === "function") {
+    return renderToStringSync(
+      arg
+    );
+  }
+  const opts = arg;
+  const sink = new StringSink();
+  renderToSinkInternal({ ...opts, sink });
+  sink.end();
+  return sink.toString();
+}
+function renderToStream(opts) {
+  const sink = new StreamSink(opts.onChunk, opts.onComplete);
+  renderToSinkInternal({ ...opts, sink });
+  sink.end();
+}
+function renderToSinkInternal(opts) {
+  const { url, routes, seed = 12345, data, sink } = opts;
+  const {
+    clearRoutes,
+    route,
+    setServerLocation,
+    lockRouteRegistration,
+    resolveRoute
+  } = route_exports;
+  clearRoutes();
+  for (const r of routes) route(r.path, r.handler, r.namespace);
+  setServerLocation(url);
+  if (process.env.NODE_ENV === "production") lockRouteRegistration();
+  const resolved = resolveRoute(url);
+  if (!resolved) throw new Error(`SSR: no route found for url: ${url}`);
+  const ctx = {
+    url,
+    seed,
+    data,
+    params: resolved.params,
+    signal: void 0
+  };
+  const node = resolved.handler(resolved.params);
+  startRenderPhase(data || null);
+  try {
+    renderNodeToSink(node, sink, ctx);
+  } finally {
+    stopRenderPhase();
+  }
+}
+
+export {
+  SSRDataMissingError,
+  getCurrentSSRContext,
+  throwSSRDataMissing,
+  getCurrentRenderData,
+  getNextKey,
+  resolvePlan,
+  collectResources,
+  resolveResources,
+  isElement,
+  cloneElement,
+  definePortal,
+  _resetDefaultPortal,
+  DefaultPortal,
+  pushSSRStrictPurityGuard,
+  popSSRStrictPurityGuard,
+  renderToStringSync,
+  renderToStringSyncForUrl,
+  renderToString,
+  renderToStream
+};
+//# sourceMappingURL=chunk-OFW6DFBM.js.map