@symbo.ls/brender 3.14.0 → 3.14.2

package/dist/cjs/hydrate.js

@@ -1,554 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var hydrate_exports = {};
-__export(hydrate_exports, {
-  collectBrNodes: () => collectBrNodes,
-  hydrate: () => hydrate
-});
-module.exports = __toCommonJS(hydrate_exports);
-const collectBrNodes = (root) => {
-  const container = root || document;
-  const nodes = container.querySelectorAll("[data-br]");
-  const map = {};
-  nodes.forEach((node) => {
-    map[node.getAttribute("data-br")] = node;
-  });
-  return map;
-};
-const hydrate = (element, options = {}) => {
-  const {
-    root,
-    events: attachEvents = true,
-    renderEvents: fireRenderEvents = true,
-    emotion,
-    designSystem
-  } = options;
-  const brNodes = collectBrNodes(root);
-  const colorMap = designSystem?.color || {};
-  const mediaMap = designSystem?.media || {};
-  let linked = 0;
-  let unlinked = 0;
-  const walk = (el) => {
-    if (!el || !el.__ref) return;
-    const brKey = el.__ref.__brKey;
-    if (brKey) {
-      const node = brNodes[brKey];
-      if (node) {
-        el.node = node;
-        node.ref = el;
-        if (emotion) {
-          renderCSS(el, emotion, colorMap, mediaMap);
-        }
-        if (attachEvents) {
-          bindEvents(el);
-        }
-        linked++;
-      } else {
-        unlinked++;
-      }
-    }
-    if (el.__ref.__children) {
-      for (const childKey of el.__ref.__children) {
-        const child = el[childKey];
-        if (child && child.__ref) walk(child);
-      }
-    }
-  };
-  walk(element);
-  if (fireRenderEvents) {
-    fireLifecycle(element);
-  }
-  return { element, linked, unlinked };
-};
-const renderCSS = (el, emotion, colorMap, mediaMap) => {
-  const { node } = el;
-  if (!node) return;
-  const css = {};
-  let hasCss = false;
-  for (const key in el) {
-    const val = el[key];
-    if (key.charCodeAt(0) === 64) {
-      const breakpoint = mediaMap[key.slice(1)];
-      if (breakpoint && typeof val === "object") {
-        const mediaCss = resolvePropsToCSS(val, colorMap);
-        if (Object.keys(mediaCss).length) {
-          css[breakpoint] = mediaCss;
-          hasCss = true;
-        }
-      }
-      continue;
-    }
-    if (key.charCodeAt(0) === 58) {
-      if (typeof val === "object") {
-        const pseudoCss = resolvePropsToCSS(val, colorMap);
-        if (Object.keys(pseudoCss).length) {
-          css["&" + key] = pseudoCss;
-          hasCss = true;
-        }
-      }
-      continue;
-    }
-    const expanded = resolveShorthand(key, val);
-    if (expanded) {
-      for (const ek in expanded) {
-        css[ek] = resolveValue(ek, expanded[ek], colorMap);
-      }
-      hasCss = true;
-      continue;
-    }
-    if (!isCSS(key)) continue;
-    css[key] = resolveValue(key, val, colorMap);
-    hasCss = true;
-  }
-  const extsCss = getExtendsCSS(el);
-  if (extsCss) {
-    for (const [k, v] of Object.entries(extsCss)) {
-      if (!css[k]) {
-        css[k] = v;
-        hasCss = true;
-      }
-    }
-  }
-  if (el.style && typeof el.style === "object") {
-    Object.assign(css, el.style);
-    hasCss = true;
-  }
-  if (!hasCss) return;
-  const emotionClass = emotion.css(css);
-  const classes = [];
-  if (emotionClass) classes.push(emotionClass);
-  if (typeof el.key === "string" && el.key.charCodeAt(0) === 95 && el.key.charCodeAt(1) !== 95) {
-    classes.push(el.key.slice(1));
-  }
-  if (el.class) classes.push(el.class);
-  if (el.attr?.class) classes.push(el.attr.class);
-  const classlist = el.classlist;
-  if (classlist) {
-    if (typeof classlist === "string") classes.push(classlist);
-    else if (typeof classlist === "object") {
-      for (const k in classlist) {
-        const v = classlist[k];
-        if (typeof v === "boolean" && v) classes.push(k);
-        else if (typeof v === "string") classes.push(v);
-        else if (typeof v === "object" && v) classes.push(emotion.css(v));
-      }
-    }
-  }
-  if (classes.length) {
-    node.setAttribute("class", classes.join(" "));
-  }
-  for (const key in el) {
-    if (isCSS(key) && node.hasAttribute(key)) {
-      node.removeAttribute(key);
-    }
-  }
-};
-const resolvePropsToCSS = (propsObj, colorMap) => {
-  const css = {};
-  for (const key in propsObj) {
-    const expanded = resolveShorthand(key, propsObj[key]);
-    if (expanded) {
-      for (const ek in expanded) css[ek] = resolveValue(ek, expanded[ek], colorMap);
-      continue;
-    }
-    if (!isCSS(key)) continue;
-    css[key] = resolveValue(key, propsObj[key], colorMap);
-  }
-  return css;
-};
-const COLOR_PROPS = /* @__PURE__ */ new Set([
-  "color",
-  "background",
-  "backgroundColor",
-  "borderColor",
-  "borderTopColor",
-  "borderRightColor",
-  "borderBottomColor",
-  "borderLeftColor",
-  "outlineColor",
-  "fill",
-  "stroke",
-  "caretColor",
-  "columnRuleColor",
-  "textDecorationColor",
-  "boxShadow",
-  "textShadow"
-]);
-const resolveValue = (key, val, colorMap) => {
-  if (typeof val !== "string") return val;
-  if (COLOR_PROPS.has(key) && colorMap[val]) return colorMap[val];
-  return val;
-};
-const NON_CSS_PROPS = /* @__PURE__ */ new Set([
-  "href",
-  "src",
-  "alt",
-  "title",
-  "id",
-  "name",
-  "type",
-  "value",
-  "placeholder",
-  "target",
-  "rel",
-  "loading",
-  "srcset",
-  "sizes",
-  "media",
-  "role",
-  "tabindex",
-  "for",
-  "action",
-  "method",
-  "enctype",
-  "autocomplete",
-  "autofocus",
-  "theme",
-  "__element",
-  "update"
-]);
-const EXTENDS_CSS = {
-  Flex: { display: "flex" },
-  InlineFlex: { display: "inline-flex" },
-  Grid: { display: "grid" },
-  InlineGrid: { display: "inline-grid" },
-  Block: { display: "block" },
-  Inline: { display: "inline" }
-};
-const getExtendsCSS = (el) => {
-  const exts = el.__ref?.__extends;
-  if (!exts || !Array.isArray(exts)) return null;
-  for (const ext of exts) {
-    if (EXTENDS_CSS[ext]) return EXTENDS_CSS[ext];
-  }
-  return null;
-};
-const resolveShorthand = (key, val) => {
-  if (typeof val === "undefined" || val === null) return null;
-  if (key === "flow" && typeof val === "string") {
-    let [direction, wrap] = (val || "row").split(" ");
-    if (val.startsWith("x") || val === "row") direction = "row";
-    if (val.startsWith("y") || val === "column") direction = "column";
-    return { display: "flex", flexFlow: (direction || "") + " " + (wrap || "") };
-  }
-  if (key === "wrap") {
-    return { display: "flex", flexWrap: val };
-  }
-  if ((key === "align" || key === "flexAlign") && typeof val === "string") {
-    const [alignItems, justifyContent] = val.split(" ");
-    return { display: "flex", alignItems, justifyContent };
-  }
-  if (key === "gridAlign" && typeof val === "string") {
-    const [alignItems, justifyContent] = val.split(" ");
-    return { display: "grid", alignItems, justifyContent };
-  }
-  if (key === "flexFlow" && typeof val === "string") {
-    let [direction, wrap] = (val || "row").split(" ");
-    if (val.startsWith("x") || val === "row") direction = "row";
-    if (val.startsWith("y") || val === "column") direction = "column";
-    return { display: "flex", flexFlow: (direction || "") + " " + (wrap || "") };
-  }
-  if (key === "flexWrap") {
-    return { display: "flex", flexWrap: val };
-  }
-  if (key === "round" || key === "borderRadius" && val) {
-    return { borderRadius: typeof val === "number" ? val + "px" : val };
-  }
-  if (key === "boxSize" && typeof val === "string") {
-    const [height, width] = val.split(" ");
-    return { height, width: width || height };
-  }
-  if (key === "widthRange" && typeof val === "string") {
-    const [minWidth, maxWidth] = val.split(" ");
-    return { minWidth, maxWidth: maxWidth || minWidth };
-  }
-  if (key === "heightRange" && typeof val === "string") {
-    const [minHeight, maxHeight] = val.split(" ");
-    return { minHeight, maxHeight: maxHeight || minHeight };
-  }
-  if (key === "column") return { gridColumn: val };
-  if (key === "columns") return { gridTemplateColumns: val };
-  if (key === "templateColumns") return { gridTemplateColumns: val };
-  if (key === "row") return { gridRow: val };
-  if (key === "rows") return { gridTemplateRows: val };
-  if (key === "templateRows") return { gridTemplateRows: val };
-  if (key === "area") return { gridArea: val };
-  if (key === "template") return { gridTemplate: val };
-  if (key === "templateAreas") return { gridTemplateAreas: val };
-  if (key === "autoColumns") return { gridAutoColumns: val };
-  if (key === "autoRows") return { gridAutoRows: val };
-  if (key === "autoFlow") return { gridAutoFlow: val };
-  if (key === "columnStart") return { gridColumnStart: val };
-  if (key === "rowStart") return { gridRowStart: val };
-  return null;
-};
-const isCSS = (key) => {
-  const ch = key.charCodeAt(0);
-  if (ch === 95 || ch === 64 || ch === 58) return false;
-  if (ch >= 65 && ch <= 90) return false;
-  if (NON_CSS_PROPS.has(key)) return false;
-  return CSS_PROPERTIES.has(key);
-};
-const CSS_PROPERTIES = /* @__PURE__ */ new Set([
-  "display",
-  "position",
-  "top",
-  "right",
-  "bottom",
-  "left",
-  "width",
-  "height",
-  "minWidth",
-  "maxWidth",
-  "minHeight",
-  "maxHeight",
-  "margin",
-  "marginTop",
-  "marginRight",
-  "marginBottom",
-  "marginLeft",
-  "marginBlock",
-  "marginInline",
-  "padding",
-  "paddingTop",
-  "paddingRight",
-  "paddingBottom",
-  "paddingLeft",
-  "paddingBlock",
-  "paddingInline",
-  "border",
-  "borderTop",
-  "borderRight",
-  "borderBottom",
-  "borderLeft",
-  "borderRadius",
-  "borderColor",
-  "borderWidth",
-  "borderStyle",
-  "borderTopWidth",
-  "borderRightWidth",
-  "borderBottomWidth",
-  "borderLeftWidth",
-  "borderTopStyle",
-  "borderRightStyle",
-  "borderBottomStyle",
-  "borderLeftStyle",
-  "borderTopColor",
-  "borderRightColor",
-  "borderBottomColor",
-  "borderLeftColor",
-  "borderTopLeftRadius",
-  "borderTopRightRadius",
-  "borderBottomLeftRadius",
-  "borderBottomRightRadius",
-  "background",
-  "backgroundColor",
-  "backgroundImage",
-  "backgroundSize",
-  "backgroundPosition",
-  "backgroundRepeat",
-  "backgroundAttachment",
-  "color",
-  "fontSize",
-  "fontWeight",
-  "fontFamily",
-  "fontStyle",
-  "lineHeight",
-  "letterSpacing",
-  "textAlign",
-  "textDecoration",
-  "textTransform",
-  "textIndent",
-  "textOverflow",
-  "textShadow",
-  "opacity",
-  "overflow",
-  "overflowX",
-  "overflowY",
-  "zIndex",
-  "cursor",
-  "pointerEvents",
-  "userSelect",
-  "flex",
-  "flexDirection",
-  "flexWrap",
-  "flexFlow",
-  "flexGrow",
-  "flexShrink",
-  "flexBasis",
-  "alignItems",
-  "alignContent",
-  "alignSelf",
-  "justifyContent",
-  "justifyItems",
-  "justifySelf",
-  "gap",
-  "rowGap",
-  "columnGap",
-  "gridTemplateColumns",
-  "gridTemplateRows",
-  "gridColumn",
-  "gridRow",
-  "gridArea",
-  "gridAutoFlow",
-  "gridAutoColumns",
-  "gridAutoRows",
-  "inset",
-  "inlineSize",
-  "blockSize",
-  "minInlineSize",
-  "maxInlineSize",
-  "minBlockSize",
-  "maxBlockSize",
-  "paddingBlockStart",
-  "paddingBlockEnd",
-  "paddingInlineStart",
-  "paddingInlineEnd",
-  "marginBlockStart",
-  "marginBlockEnd",
-  "marginInlineStart",
-  "marginInlineEnd",
-  "transform",
-  "transformOrigin",
-  "transition",
-  "animation",
-  "animationName",
-  "animationDuration",
-  "animationDelay",
-  "animationTimingFunction",
-  "animationFillMode",
-  "animationIterationCount",
-  "animationPlayState",
-  "animationDirection",
-  "gridTemplate",
-  "gridTemplateAreas",
-  "gridColumnStart",
-  "gridRowStart",
-  "boxShadow",
-  "outline",
-  "outlineColor",
-  "outlineWidth",
-  "outlineStyle",
-  "outlineOffset",
-  "whiteSpace",
-  "wordBreak",
-  "wordWrap",
-  "overflowWrap",
-  "visibility",
-  "boxSizing",
-  "objectFit",
-  "objectPosition",
-  "filter",
-  "backdropFilter",
-  "mixBlendMode",
-  "fill",
-  "stroke",
-  "strokeWidth",
-  "listStyle",
-  "listStyleType",
-  "listStylePosition",
-  "counterReset",
-  "counterIncrement",
-  "content",
-  "aspectRatio",
-  "resize",
-  "appearance",
-  "scrollBehavior",
-  "scrollMargin",
-  "scrollPadding",
-  "willChange",
-  "contain",
-  "isolation",
-  "caretColor",
-  "accentColor",
-  "columnCount",
-  "columnGap",
-  "columnRuleColor",
-  "columnRuleStyle",
-  "columnRuleWidth",
-  "textDecorationColor",
-  "textDecorationStyle",
-  "textDecorationThickness",
-  "clipPath",
-  "shapeOutside"
-]);
-const DOMQL_LIFECYCLE = /* @__PURE__ */ new Set([
-  "render",
-  "create",
-  "init",
-  "start",
-  "complete",
-  "done",
-  "beforeClassAssign",
-  "attachNode",
-  "stateInit",
-  "stateCreated",
-  "renderRouter",
-  "lazyLoad",
-  "error"
-]);
-const bindEvents = (el) => {
-  const { node } = el;
-  if (!node) return;
-  if (!el.__ref.__eventCleanup) el.__ref.__eventCleanup = [];
-  for (const key in el) {
-    if (key.length <= 2 || key[0] !== "o" || key[1] !== "n") continue;
-    if (typeof el[key] !== "function") continue;
-    const third = key[2];
-    if (third !== third.toUpperCase()) continue;
-    const eventName = third.toLowerCase() + key.slice(3);
-    if (DOMQL_LIFECYCLE.has(eventName)) continue;
-    addListener(node, eventName, el[key], el);
-  }
-};
-const addListener = (node, eventName, handler, el) => {
-  const listener = (event) => {
-    try {
-      handler.call(el, event, el, el.state, el.context);
-    } catch (e) {
-      console.warn("[brender hydrate]", eventName, e.message);
-    }
-  };
-  node.addEventListener(eventName, listener);
-  el.__ref.__eventCleanup.push(() => node.removeEventListener(eventName, listener));
-};
-const fireLifecycle = (el) => {
-  if (!el || !el.__ref || !el.node) return;
-  fireEvent(el.onRender, el);
-  fireEvent(el.onRenderRouter, el);
-  fireEvent(el.onDone, el);
-  fireEvent(el.onCreate, el);
-  if (el.__ref.__children) {
-    for (const childKey of el.__ref.__children) {
-      const child = el[childKey];
-      if (child && child.__ref) fireLifecycle(child);
-    }
-  }
-};
-const fireEvent = (fn, el) => {
-  if (typeof fn !== "function") return;
-  try {
-    const result = fn.call(el, el, el.state, el.context);
-    if (result && typeof result.then === "function") {
-      result.catch(() => {
-      });
-    }
-  } catch (e) {
-    console.warn("[brender hydrate]", el.key, e.message);
-  }
-};

package/dist/cjs/index.js

@@ -1,72 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var index_exports = {};
-__export(index_exports, {
-  assignKeys: () => import_keys.assignKeys,
-  collectBrNodes: () => import_hydrate.collectBrNodes,
-  createEnv: () => import_env.createEnv,
-  default: () => index_default,
-  extractMetadata: () => import_metadata.extractMetadata,
-  generateHeadHtml: () => import_metadata.generateHeadHtml,
-  generateSitemap: () => import_sitemap.generateSitemap,
-  getAccumulatedEmotionCSS: () => import_render.getAccumulatedEmotionCSS,
-  hydrate: () => import_hydrate.hydrate,
-  injectPrefetchedState: () => import_prefetch.injectPrefetchedState,
-  loadAndRenderAll: () => import_load.loadAndRenderAll,
-  loadProject: () => import_load.loadProject,
-  mapKeysToElements: () => import_keys.mapKeysToElements,
-  prefetchPageData: () => import_prefetch.prefetchPageData,
-  render: () => import_render.render,
-  renderElement: () => import_render.renderElement,
-  renderPage: () => import_render.renderPage,
-  renderRoute: () => import_render.renderRoute,
-  replaceEmotionCSS: () => import_render.replaceEmotionCSS,
-  resetGlobalCSSCache: () => import_render.resetGlobalCSSCache,
-  resetKeys: () => import_keys.resetKeys
-});
-module.exports = __toCommonJS(index_exports);
-var import_env = require("./env.js");
-var import_keys = require("./keys.js");
-var import_load = require("./load.js");
-var import_render = require("./render.js");
-var import_metadata = require("./metadata.js");
-var import_hydrate = require("./hydrate.js");
-var import_sitemap = require("./sitemap.js");
-var import_prefetch = require("./prefetch.js");
-var index_default = {
-  createEnv: import_env.createEnv,
-  resetKeys: import_keys.resetKeys,
-  assignKeys: import_keys.assignKeys,
-  mapKeysToElements: import_keys.mapKeysToElements,
-  loadProject: import_load.loadProject,
-  loadAndRenderAll: import_load.loadAndRenderAll,
-  render: import_render.render,
-  renderElement: import_render.renderElement,
-  renderRoute: import_render.renderRoute,
-  renderPage: import_render.renderPage,
-  resetGlobalCSSCache: import_render.resetGlobalCSSCache,
-  getAccumulatedEmotionCSS: import_render.getAccumulatedEmotionCSS,
-  replaceEmotionCSS: import_render.replaceEmotionCSS,
-  extractMetadata: import_metadata.extractMetadata,
-  generateHeadHtml: import_metadata.generateHeadHtml,
-  collectBrNodes: import_hydrate.collectBrNodes,
-  hydrate: import_hydrate.hydrate,
-  generateSitemap: import_sitemap.generateSitemap,
-  prefetchPageData: import_prefetch.prefetchPageData,
-  injectPrefetchedState: import_prefetch.injectPrefetchedState
-};

package/dist/cjs/keys.js

@@ -1,62 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var keys_exports = {};
-__export(keys_exports, {
-  assignKeys: () => assignKeys,
-  mapKeysToElements: () => mapKeysToElements,
-  resetKeys: () => resetKeys
-});
-module.exports = __toCommonJS(keys_exports);
-let _keyCounter = 0;
-const resetKeys = () => {
-  _keyCounter = 0;
-};
-const assignKeys = (node) => {
-  if (!node) return;
-  if (node.nodeType === 1) {
-    const key = `br-${_keyCounter++}`;
-    node.setAttribute("data-br", key);
-  }
-  const children = node.childNodes;
-  if (children) {
-    for (let i = 0; i < children.length; i++) {
-      assignKeys(children[i]);
-    }
-  }
-};
-const mapKeysToElements = (element, registry = {}) => {
-  if (!element) return registry;
-  const node = element.node;
-  if (node && node.getAttribute) {
-    const brKey = node.getAttribute("data-br");
-    if (brKey) {
-      if (!element.__ref) element.__ref = {};
-      element.__ref.__brKey = brKey;
-      registry[brKey] = element;
-    }
-  }
-  if (element.__ref && element.__ref.__children) {
-    for (const childKey of element.__ref.__children) {
-      const child = element[childKey];
-      if (child && child.__ref) {
-        mapKeysToElements(child, registry);
-      }
-    }
-  }
-  return registry;
-};