lithent 0.1.0

package/dist/lithent.mjs

@@ -0,0 +1,867 @@
+const checkCustemComponentFunction = (target) => typeof target === "function" && !checkFragmentFunction(target) || typeof target === "object" && "resolve" in target;
+const checkFragmentFunction = (target) => typeof target === "function" && target === Fragment;
+const checkPlainWDomType = (wDom) => typeof wDom === "object" && !("resolve" in wDom);
+const checkPlainType = (wDom, typeName) => checkPlainWDomType(wDom) && wDom.type === typeName;
+const checkEmptyElement = (wDom) => checkPlainWDomType(wDom) && !wDom.type;
+const checkSameCustomComponent = ({
+  originalWDom,
+  newWDom
+}) => newWDom.constructor === (originalWDom == null ? void 0 : originalWDom.constructor);
+const checkSameFragment = ({ originalWDom, newWDom }) => {
+  var _a, _b;
+  return checkPlainWDomType(newWDom) && (originalWDom == null ? void 0 : originalWDom.type) === "fragment" && ((_a = originalWDom == null ? void 0 : originalWDom.children) == null ? void 0 : _a.length) === ((_b = newWDom == null ? void 0 : newWDom.children) == null ? void 0 : _b.length);
+};
+const checkSameTagElement = ({ originalWDom, newWDom }) => checkPlainWDomType(newWDom) && (originalWDom == null ? void 0 : originalWDom.type) === "element" && (originalWDom == null ? void 0 : originalWDom.tag) === newWDom.tag;
+const checkNormalTypeElement = ({ originalWDom, newWDom }) => checkPlainWDomType(newWDom) && (originalWDom == null ? void 0 : originalWDom.type) === newWDom.type;
+const checkExisty = (value) => value !== null && value !== void 0;
+const checkFunction = (target) => typeof target === "function";
+const checkStyleData = (dataKey, dataValue) => dataKey === "style" && typeof dataValue === "object";
+const checkRefData = (dataKey, dataValue) => dataKey === "ref" && typeof dataValue === "object";
+const checkOptionElement = (element) => {
+  return element.nodeType === 1 && element.tagName === "OPTION";
+};
+const checkNormalAttribute = (dataValue) => typeof dataValue === "number" || typeof dataValue === "string";
+const getWDomType = (wDom) => {
+  let result;
+  if (checkCustemComponentFunction(wDom)) {
+    result = "c";
+  } else if (checkPlainType(wDom, "fragment")) {
+    result = "f";
+  } else if (checkPlainType(wDom, "element")) {
+    result = "e";
+  } else if (checkPlainType(wDom, "loop")) {
+    result = "l";
+  } else if (checkPlainType(wDom, "text")) {
+    result = "t";
+  } else if (checkEmptyElement(wDom)) {
+    result = "et";
+  }
+  return result;
+};
+const checkSameWDomWithOriginal = {
+  c: checkSameCustomComponent,
+  l: checkNormalTypeElement,
+  t: checkNormalTypeElement,
+  e: checkSameTagElement,
+  f: checkSameFragment,
+  et: checkNormalTypeElement
+};
+const getParent = (vDom) => {
+  const parentVDom = vDom.getParent && vDom.getParent();
+  if (!parentVDom) {
+    throw Error("Not found parent vDom");
+  }
+  return parentVDom;
+};
+const reRender = (vDom, infoVdom) => {
+  const { componentProps: props, componentChildren: children } = vDom;
+  const { props: infoProps, children: infoChidren } = infoVdom;
+  if (props) {
+    updateProps$1(props, infoProps);
+  }
+  if (children) {
+    updateChildren(children, infoChidren);
+  }
+  const newVDom = vDom.reRender && vDom.reRender();
+  if (!newVDom) {
+    throw Error("Unable reRender");
+  }
+  return newVDom;
+};
+const updateProps$1 = (props, infoProps) => {
+  if (props && infoProps !== props) {
+    Object.keys(props).forEach((key) => delete props[key]);
+    Object.entries(infoProps || {}).forEach(
+      ([key, value]) => props[key] = value
+    );
+  }
+};
+const updateChildren = (children, infoChidren) => {
+  if (children && infoChidren !== children) {
+    children.splice(0, children.length);
+    if (infoChidren) {
+      infoChidren.forEach((childrenItem) => children.push(childrenItem));
+    }
+  }
+};
+const componentKeyRef = { value: {} };
+const needDiffRef = { value: false };
+const componentRef = /* @__PURE__ */ new WeakMap();
+const redrawQueue = { value: [] };
+const redrawQueueTimeout = { value: null };
+const nodeChildKeyList = { value: [] };
+const pushNodeChildKey = (key) => nodeChildKeyList.value.forEach((item) => item.value.push(key));
+const removeNodeChildKey = (item) => {
+  nodeChildKeyList.value.splice(nodeChildKeyList.value.indexOf(item), 1);
+};
+const cleanNodeChildKey = () => nodeChildKeyList.value = [];
+const dataStoreStore = {};
+const dataStoreRenderQueue = {};
+const componentRender = (componentKey) => () => {
+  var _a;
+  const up = (_a = componentRef.get(componentKey)) == null ? void 0 : _a.up;
+  if (up) {
+    up();
+    return true;
+  } else {
+    return false;
+  }
+};
+const setComponetRef = (componentKey) => {
+  componentRef.set(componentKey, {
+    up: () => {
+    },
+    upR: [],
+    upS: { value: 0 },
+    upD: [],
+    upCB: [],
+    mts: [],
+    umts: []
+  });
+};
+const getComponentKey = () => componentKeyRef.value;
+const setRedrawAction = ({
+  componentKey,
+  nodeChildKey,
+  exec
+}) => {
+  componentRef.get(componentKey).up = () => {
+    redrawQueue.value.push({
+      componentKey,
+      nodeChildKey: nodeChildKey.value,
+      exec
+    });
+    if (!redrawQueueTimeout.value) {
+      redrawQueueTimeout.value = setTimeout(execRedrawQueue);
+    }
+  };
+};
+const initUpdateHookState = (componentKey) => componentKeyRef.value = componentKey;
+const initMountHookState = (componentKey) => {
+  componentKeyRef.value = componentKey;
+  setComponetRef(componentKey);
+};
+const execRedrawQueue = () => {
+  let childItemList = [];
+  redrawQueue.value.forEach((item) => {
+    childItemList = childItemList.concat(item.nodeChildKey);
+  });
+  const addedKey = [];
+  const result = redrawQueue.value.reduce((acc, item) => {
+    const { componentKey } = item;
+    if (childItemList.includes(componentKey) || addedKey.includes(componentKey)) {
+      return acc;
+    }
+    addedKey.push(componentKey);
+    acc.push(item);
+    return acc;
+  }, []);
+  while (result.length) {
+    const action = result.shift();
+    if (action) {
+      action.exec();
+    }
+  }
+};
+const unmount = (effectAction) => {
+  componentRef.get(getComponentKey()).umts.push(effectAction);
+};
+const runUnmountQueueFromWDom = (newWDom) => {
+  const { componentKey, nodeChildKey } = newWDom;
+  const childKeys = nodeChildKey == null ? void 0 : nodeChildKey.value;
+  if (componentKey) {
+    removeItem(componentKey);
+  }
+  if (childKeys) {
+    childKeys.forEach((childKey) => removeItem(childKey));
+  }
+};
+const removeItem = (componentKey) => {
+  const queue = componentRef.get(componentKey).umts;
+  componentRef.get(componentKey).umts = [];
+  queue.forEach((effect) => effect());
+  componentRef.delete(componentKey);
+};
+const mountCallback = (effectAction) => {
+  const mts = componentRef.get(getComponentKey()).mts;
+  mts.push(effectAction);
+};
+const runMountedQueueFromWDom = (newWDom) => {
+  const { componentKey } = newWDom;
+  if (componentKey) {
+    const component = componentRef.get(componentKey);
+    const queue = component == null ? void 0 : component.mts;
+    const sequence = component == null ? void 0 : component.upS;
+    componentKeyRef.value = componentKey;
+    if (sequence) {
+      sequence.value = 0;
+    }
+    if (queue) {
+      component.mts = [];
+      queue.forEach((effect) => {
+        const callback = effect();
+        if (callback) {
+          unmount(callback);
+        }
+      });
+    }
+  }
+};
+const useUpdated = (effectAction, dependencies = () => []) => {
+  const component = componentRef.get(getComponentKey());
+  const { upD, upS } = component;
+  const def = upD[upS.value];
+  if (def && checkNeedPushQueue(def, dependencies())) {
+    const callback = effectAction();
+    if (callback) {
+      component.upCB.push(callback);
+    }
+  }
+  upD[upS.value] = dependencies();
+  upS.value += 1;
+};
+const runUpdatedQueueFromWDom = (newWDom) => {
+  const { componentKey } = newWDom;
+  if (componentKey) {
+    const component = componentRef.get(componentKey);
+    const queue = component == null ? void 0 : component.upCB;
+    const sequence = component == null ? void 0 : component.upS;
+    componentKeyRef.value = componentKey;
+    if (sequence) {
+      sequence.value = 0;
+    }
+    if (newWDom.constructor && queue) {
+      component.upCB = [];
+      queue.forEach((effect) => effect());
+    }
+  }
+};
+const checkNeedPushQueue = (originalDefs, newDefs) => !originalDefs.length && !originalDefs.length ? true : originalDefs.some((def, index) => def !== newDefs[index]);
+const render = (wDom, wrapElement, afterElement) => {
+  if (!wrapElement) {
+    throw Error("WrapELement is null");
+  }
+  wDom.isRoot = true;
+  wDom.wrapElement = wrapElement;
+  const Dom = wDomToDom(wDom, true);
+  if (afterElement) {
+    wrapElement.insertBefore(Dom, afterElement);
+  } else {
+    wrapElement.appendChild(Dom);
+  }
+};
+const wDomUpdate = (newWDomTree) => {
+  const { needRerender } = newWDomTree;
+  if (needRerender && needRerender !== "N") {
+    const exec = {
+      A: typeAdd,
+      D: typeDelete,
+      R: typeReplace,
+      U: typeUpdate,
+      SR: typeSortedReplace,
+      SU: typeSortedUpdate
+    }[needRerender];
+    exec(newWDomTree);
+  }
+};
+const recursiveRemoveEvent = (originalWDom) => {
+  if (originalWDom.props && originalWDom.el) {
+    removeEvent(originalWDom.props, originalWDom.el);
+  }
+  (originalWDom.children || []).forEach((childItem) => {
+    recursiveRemoveEvent(childItem);
+  });
+};
+const typeDelete = (newWDom) => {
+  var _a, _b;
+  const parent = findRealParentElement(newWDom);
+  if (newWDom.oldProps && newWDom.el) {
+    removeEvent(newWDom.oldProps, newWDom.el);
+  }
+  if (parent && newWDom.el) {
+    if (((_a = newWDom.el) == null ? void 0 : _a.nodeType) === 1) {
+      parent.removeChild(newWDom.el);
+    } else if (((_b = newWDom.el) == null ? void 0 : _b.nodeType) === 11) {
+      findChildWithRemoveElement(newWDom, parent);
+    }
+    delete newWDom.el;
+  }
+};
+const findChildWithRemoveElement = (newWDom, parent) => {
+  ((newWDom == null ? void 0 : newWDom.children) || []).forEach((item) => {
+    var _a, _b;
+    if (((_a = item.el) == null ? void 0 : _a.nodeType) === 1) {
+      parent.removeChild(item == null ? void 0 : item.el);
+    } else if (((_b = item.el) == null ? void 0 : _b.nodeType) === 11) {
+      findChildWithRemoveElement(item, parent);
+    }
+  });
+};
+const typeSortedReplace = (newWDom) => {
+  typeDelete(newWDom);
+  typeAdd(newWDom);
+};
+const typeSortedUpdate = (newWDom) => {
+  typeDelete(newWDom);
+  typeAdd(newWDom, newWDom.el);
+};
+const typeAdd = (newWDom, newElement) => {
+  if (!newElement) {
+    newElement = wDomToDom(newWDom, true);
+  }
+  const parentWDom = getParent(newWDom);
+  if (parentWDom.type) {
+    const parentEl = findRealParentElement(parentWDom);
+    const nextEl = startFindNextBrotherElement(newWDom, parentWDom);
+    if (newElement && parentEl) {
+      if (nextEl) {
+        parentEl.insertBefore(newElement, nextEl);
+      } else {
+        parentEl.appendChild(newElement);
+      }
+    }
+  }
+  runMountedQueueFromWDom(newWDom);
+};
+const startFindNextBrotherElement = (wDom, parentWDom) => {
+  const brothers = parentWDom.children || [];
+  const index = brothers.indexOf(wDom);
+  const nextIndex = index + 1;
+  const candidiateBrothers = brothers.slice(nextIndex);
+  const finedNextEl = findChildFragmentNextElement(candidiateBrothers);
+  const parentType = parentWDom.type || "";
+  if (finedNextEl) {
+    return finedNextEl;
+  }
+  if (!parentWDom.isRoot && ["fragment", "loop"].includes(parentType)) {
+    return startFindNextBrotherElement(parentWDom, getParent(parentWDom));
+  }
+  return void 0;
+};
+const findChildFragmentNextElement = (candidiateBrothers) => candidiateBrothers.reduce(
+  (targetEl, bItem) => {
+    const type = bItem.type;
+    const el = bItem.el;
+    const isFragment = type && ["fragment", "loop"].includes(type);
+    if (targetEl) {
+      return targetEl;
+    } else if (isFragment) {
+      return findChildFragmentNextElement(bItem.children || []);
+    } else if (el && el.nodeType !== 11) {
+      return el;
+    }
+    return targetEl;
+  },
+  void 0
+);
+const typeReplace = (newWDom) => {
+  const parentWDom = getParent(newWDom);
+  const orignalElement = newWDom.el;
+  if (parentWDom.type && orignalElement) {
+    const parentElement = parentWDom.el;
+    const newElement = wDomToDom(newWDom, true);
+    if (newWDom.oldProps) {
+      removeEvent(newWDom.oldProps, orignalElement);
+    }
+    if (parentElement) {
+      parentElement.replaceChild(newElement, orignalElement);
+    }
+  }
+  runMountedQueueFromWDom(newWDom);
+};
+const removeEvent = (oldProps, element) => {
+  if (element) {
+    Object.entries(oldProps || {}).forEach(
+      ([dataKey, dataValue]) => {
+        if (dataKey.match(/^on/)) {
+          element.removeEventListener(dataKey, dataValue);
+        }
+      }
+    );
+  }
+};
+const typeUpdate = (newWDom) => {
+  var _a;
+  const element = newWDom.el;
+  if (newWDom.type === "text") {
+    updateText(newWDom);
+    return;
+  }
+  if (element) {
+    const { oldProps, props } = newWDom;
+    updateProps({ oldProps, props, element });
+    delete newWDom.oldProps;
+    if (newWDom.tag === "input") {
+      element.value = String(((_a = newWDom == null ? void 0 : newWDom.props) == null ? void 0 : _a.value) || "");
+    }
+  }
+  (newWDom.children || []).forEach((childItem) => wDomUpdate(childItem));
+  runUpdatedQueueFromWDom(newWDom);
+};
+const updateText = (newWDom) => {
+  const element = newWDom.el;
+  if (element) {
+    element.nodeValue = String(newWDom.text);
+  }
+};
+const updateProps = ({
+  oldProps,
+  props,
+  element
+}) => {
+  const originalProps = { ...oldProps };
+  Object.entries(props || {}).forEach(
+    ([dataKey, dataValue]) => {
+      if (dataKey === "key")
+        ;
+      else if (checkStyleData(dataKey, dataValue)) {
+        const style = dataValue;
+        const oldStyle = checkStyleData(dataKey, originalProps.style) || {};
+        updateStyle({ style, oldStyle, element });
+      } else if (checkRefData(dataKey, dataValue)) {
+        dataValue.value = element;
+      } else if (dataKey.match(/^on/)) {
+        updateEvent({
+          element,
+          eventKey: dataKey,
+          newEventHandler: dataValue,
+          oldEventHandler: originalProps[dataKey]
+        });
+      } else if (checkNormalAttribute(dataValue)) {
+        element.setAttribute(dataKey, String(dataValue));
+      } else if (checkOptionElement(element) && dataKey === "selected") {
+        element.selected = !!dataValue;
+      }
+      delete originalProps[dataKey];
+    }
+  );
+  Object.keys(originalProps).forEach(
+    (dataKey) => element.removeAttribute(dataKey)
+  );
+};
+const wDomToDom = (wDom, init) => {
+  let element;
+  const { type, tag, text, props, children = [] } = wDom;
+  const isVirtualType = type === "fragment" || type === "loop";
+  if (isVirtualType) {
+    element = new DocumentFragment();
+  } else if (type === "element" && tag) {
+    element = document.createElement(tag);
+  } else if (type === "text" && checkExisty(text)) {
+    element = document.createTextNode(String(text));
+  }
+  wDomChildrenToDom(children, element, init);
+  updateProps({ props, element });
+  wDom.el = element;
+  runMountedQueueFromWDom(wDom);
+  return element || document.createElement("div");
+};
+const wDomChildrenToDom = (children, parentElement, init) => {
+  if (init) {
+    const elementChildren = children.reduce(
+      (acc, childItem) => {
+        if (childItem.type) {
+          acc.appendChild(wDomToDom(childItem, init));
+        }
+        return acc;
+      },
+      new DocumentFragment()
+    );
+    if (parentElement && elementChildren.hasChildNodes()) {
+      parentElement.appendChild(elementChildren);
+    }
+  }
+};
+const updateEvent = ({
+  element,
+  eventKey,
+  newEventHandler,
+  oldEventHandler
+}) => {
+  const eventName = eventKey.replace(
+    /^on(.*)/,
+    (_match, p1) => p1.toLowerCase()
+  );
+  if (oldEventHandler !== newEventHandler) {
+    if (oldEventHandler) {
+      element.removeEventListener(eventName, oldEventHandler);
+    }
+    if (newEventHandler) {
+      element.addEventListener(eventName, newEventHandler);
+    }
+  }
+};
+const updateStyle = ({
+  style,
+  oldStyle,
+  element
+}) => {
+  const originalStyle = { ...oldStyle };
+  const elementStyle = element == null ? void 0 : element.style;
+  if (elementStyle) {
+    Object.entries(style).forEach(([styleKey, dataValue]) => {
+      elementStyle.setProperty(styleKey, dataValue);
+      delete originalStyle[styleKey];
+    });
+    Object.entries(originalStyle).forEach(
+      ([styleKey]) => elementStyle.removeProperty(styleKey)
+    );
+  }
+};
+const findRealParentElement = (vDom) => {
+  var _a, _b;
+  const isVirtualType = vDom.type === "fragment" || vDom.type === "loop" || !vDom.type && ((_a = vDom == null ? void 0 : vDom.el) == null ? void 0 : _a.nodeType) === 11;
+  if (vDom.isRoot && isVirtualType) {
+    return vDom.wrapElement;
+  }
+  if (!isVirtualType) {
+    return (_b = vDom.el) == null ? void 0 : _b.parentNode;
+  }
+  const parentVDom = getParent(vDom);
+  return findRealParentElement(parentVDom);
+};
+const makeNewWDomTree = ({
+  originalWDom,
+  newWDom
+}) => {
+  const type = getWDomType(newWDom);
+  if (!type) {
+    throw new Error("Unknown type wdom");
+  }
+  const isSameType = checkSameWDomWithOriginal[type]({ originalWDom, newWDom });
+  const result = remakeNewWDom({ originalWDom, newWDom, isSameType });
+  if (result == null ? void 0 : result.nodeChildKey) {
+    removeNodeChildKey(result.nodeChildKey);
+  }
+  return result;
+};
+const remakeNewWDom = ({
+  newWDom,
+  originalWDom,
+  isSameType
+}) => {
+  const remakeWDom = generalize({ newWDom, originalWDom, isSameType });
+  remakeWDom.children = remakeChildrenForDiff({
+    isSameType,
+    newWDom: remakeWDom,
+    originalWDom
+  });
+  const needRerender = addReRenderTypeProperty({
+    originalWDom,
+    newWDom: remakeWDom,
+    isSameType
+  });
+  remakeWDom.needRerender = needRerender;
+  if (needRerender !== "A" && originalWDom) {
+    remakeWDom.el = originalWDom.el;
+  }
+  if (needRerender && ["D", "R", "SR"].includes(needRerender) && (originalWDom == null ? void 0 : originalWDom.componentKey)) {
+    runUnmountQueueFromWDom(originalWDom);
+    recursiveRemoveEvent(originalWDom);
+    remakeWDom.children = originalWDom.children;
+  }
+  remakeWDom.oldProps = originalWDom == null ? void 0 : originalWDom.props;
+  return remakeWDom;
+};
+const addReRenderTypeProperty = ({
+  originalWDom,
+  newWDom,
+  isSameType
+}) => {
+  const existOriginalWDom = originalWDom && originalWDom.type;
+  const isEmptyElement = checkEmptyElement(newWDom);
+  const isRoot = !newWDom.getParent;
+  const parentType = !isRoot && getParent(newWDom).type;
+  const key = getKey(newWDom);
+  const isKeyCheckedWDom = parentType === "loop" && checkExisty(key);
+  const isSameText = newWDom.type === "text" && isSameType && newWDom.text === (originalWDom == null ? void 0 : originalWDom.text);
+  let result;
+  if (isEmptyElement) {
+    result = "D";
+  } else if (isSameText) {
+    result = "N";
+  } else if (!existOriginalWDom) {
+    result = "A";
+  } else if (isSameType) {
+    result = isKeyCheckedWDom ? "SU" : "U";
+  } else {
+    result = isKeyCheckedWDom ? "SR" : "R";
+  }
+  return result;
+};
+const generalize = ({
+  newWDom,
+  originalWDom,
+  isSameType
+}) => {
+  if (checkCustemComponentFunction(newWDom)) {
+    return isSameType && originalWDom ? reRender(originalWDom, newWDom) : newWDom.resolve();
+  }
+  return newWDom;
+};
+const remakeChildrenForDiff = ({
+  isSameType,
+  newWDom,
+  originalWDom
+}) => isSameType && originalWDom ? remakeChildrenForUpdate(newWDom, originalWDom) : remakeChildrenForAdd(newWDom);
+const remakeChildrenForAdd = (newWDom) => (newWDom.children || []).map((item) => {
+  const childItem = makeNewWDomTree({ newWDom: item });
+  childItem.getParent = () => newWDom;
+  return childItem;
+});
+const remakeChildrenForUpdate = (newWDom, originalWDom) => {
+  if (newWDom.type === "loop" && checkExisty(getKey((newWDom.children || [])[0]))) {
+    return remakeChildrenForLoopUpdate(newWDom, originalWDom);
+  }
+  return (newWDom.children || []).map((item, index) => {
+    const childItem = makeNewWDomTree({
+      newWDom: item,
+      originalWDom: (originalWDom.children || [])[index]
+    });
+    childItem.getParent = () => newWDom;
+    return childItem;
+  });
+};
+const remakeChildrenForLoopUpdate = (newWDom, originalWDom) => {
+  const { remakedChildren, unUsedChildren } = diffLoopChildren(
+    newWDom,
+    originalWDom
+  );
+  unUsedChildren.map((unusedItem) => {
+    const el = unusedItem.el;
+    if (el && el.parentNode) {
+      el.parentNode.removeChild(el);
+    }
+  });
+  return remakedChildren;
+};
+const diffLoopChildren = (newWDom, originalWDom) => {
+  const newChildren = [...newWDom.children || []];
+  const originalChildren = [...originalWDom.children || []];
+  const remakedChildren = newChildren.map((item) => {
+    const originalItem = findSameKeyOriginalItem(item, originalChildren);
+    const childItem = makeNewWDomTree({
+      newWDom: item,
+      originalWDom: originalItem
+    });
+    if (originalItem) {
+      originalChildren.splice(originalChildren.indexOf(originalItem), 1);
+    }
+    childItem.getParent = () => newWDom;
+    return childItem;
+  });
+  return {
+    remakedChildren,
+    unUsedChildren: originalChildren
+  };
+};
+const findSameKeyOriginalItem = (item, originalChildren) => {
+  const key = getKey(item);
+  return originalChildren.find(
+    (orignalChildItem) => getKey(orignalChildItem) === key
+  );
+};
+const getKey = (target) => {
+  var _a, _b, _c;
+  return (_c = (_a = target == null ? void 0 : target.componentProps) == null ? void 0 : _a.key) != null ? _c : (_b = target == null ? void 0 : target.props) == null ? void 0 : _b.key;
+};
+const updateCallback = (effectAction, dependencies = () => []) => {
+  const updateReqs = componentRef.get(getComponentKey()).upR;
+  updateReqs.push(() => useUpdated(effectAction, dependencies));
+  useUpdated(effectAction, dependencies);
+};
+const runUpdateCallback = () => {
+  var _a;
+  const updateReqs = (_a = componentRef.get(getComponentKey())) == null ? void 0 : _a.upR;
+  if (updateReqs == null ? void 0 : updateReqs.length) {
+    updateReqs.forEach((callback) => callback());
+  }
+  redrawQueue.value = [];
+  redrawQueueTimeout.value = null;
+};
+const Fragment = (_props, ...children) => ({
+  type: "fragment",
+  children
+});
+const h = (tag, props, ...children) => {
+  const nodeParentPointer = { value: void 0 };
+  const newProps = props || {};
+  const newChildren = remakeChildren(nodeParentPointer, children);
+  const node = makeNode({
+    tag,
+    props: newProps,
+    children: newChildren
+  });
+  if (!checkCustemComponentFunction(node)) {
+    nodeParentPointer.value = node;
+  }
+  return node;
+};
+const mount = (component) => (_props, _children) => component;
+const reRenderCustomComponent = ({
+  tag,
+  props,
+  children,
+  originalWDom
+}) => {
+  var _a;
+  needDiffRef.value = true;
+  cleanNodeChildKey();
+  const newWDom = makeWDomResolver({ tag, props, children });
+  const newWDomTree = makeNewWDomTree({ originalWDom, newWDom });
+  const { isRoot, getParent: getParent2, wrapElement } = originalWDom;
+  newWDomTree.getParent = getParent2;
+  if (!isRoot && getParent2) {
+    const brothers = ((_a = getParent2()) == null ? void 0 : _a.children) || [];
+    const index = brothers.indexOf(originalWDom);
+    brothers.splice(index, 1, newWDomTree);
+  } else {
+    newWDomTree.isRoot = true;
+    newWDomTree.wrapElement = wrapElement;
+  }
+  wDomUpdate(newWDomTree);
+  needDiffRef.value = false;
+};
+const makeWDomResolver = ({
+  tag,
+  props,
+  children
+}) => {
+  const tagName = tag.name;
+  const constructor = tag;
+  const resolve = (componentKey = props) => {
+    initMountHookState(componentKey);
+    const nodeChildKey = { value: [] };
+    pushNodeChildKey(componentKey);
+    nodeChildKeyList.value.push(nodeChildKey);
+    const component = tag(props, children);
+    const componentMaker = component(
+      componentRender(componentKey),
+      props,
+      children
+    );
+    const customNode = makeCustomNode({
+      componentMaker,
+      componentKey,
+      tag,
+      props,
+      children,
+      nodeChildKey
+    });
+    const originalWDom = customNode;
+    setRedrawAction({
+      componentKey,
+      nodeChildKey,
+      exec: () => reRenderCustomComponent({ tag, props, children, originalWDom })
+    });
+    if (!needDiffRef.value) {
+      removeNodeChildKey(nodeChildKey);
+    }
+    return customNode;
+  };
+  return { tagName, constructor, props, children, resolve };
+};
+const makeCustomNode = (wDomInfo) => {
+  const { componentMaker } = wDomInfo;
+  const customNode = componentMaker();
+  const reRender2 = makeReRender(wDomInfo);
+  addComponentProps(customNode, { ...wDomInfo, reRender: reRender2 });
+  return customNode;
+};
+const makeReRender = (wDomInfo) => {
+  const reRender2 = () => wDomMaker({ ...wDomInfo, reRender: reRender2 });
+  return reRender2;
+};
+const wDomMaker = (wDomInfo) => {
+  const { componentMaker, componentKey, tag, props, children } = wDomInfo;
+  initUpdateHookState(componentKey);
+  runUpdateCallback();
+  const nodeChildKey = { value: [] };
+  pushNodeChildKey(componentKey);
+  nodeChildKeyList.value.push(nodeChildKey);
+  const originalWDom = componentMaker();
+  wDomInfo.nodeChildKey = nodeChildKey;
+  setRedrawAction({
+    componentKey,
+    nodeChildKey,
+    exec: () => reRenderCustomComponent({ tag, props, children, originalWDom })
+  });
+  addComponentProps(originalWDom, wDomInfo);
+  if (!needDiffRef.value) {
+    removeNodeChildKey(nodeChildKey);
+  }
+  return originalWDom;
+};
+const addComponentProps = (wDom, info) => {
+  const { componentKey, tag, props, children, reRender: reRender2, nodeChildKey } = info;
+  Object.assign(wDom, {
+    componentProps: props,
+    componentChildren: children,
+    constructor: tag,
+    tagName: tag.name,
+    componentKey,
+    nodeChildKey,
+    reRender: reRender2
+  });
+};
+const makeNode = ({
+  tag,
+  props,
+  children
+}) => {
+  if (checkFragmentFunction(tag)) {
+    return Fragment(props, ...children);
+  } else if (checkCustemComponentFunction(tag)) {
+    const componetMakeResolver = makeWDomResolver({ tag, props, children });
+    return needDiffRef.value ? componetMakeResolver : componetMakeResolver.resolve();
+  }
+  return {
+    type: "element",
+    tag,
+    props,
+    children
+  };
+};
+const remakeChildren = (nodeParentPointer, children) => children.map((item) => {
+  const childItem = makeChildrenItem(item);
+  childItem.getParent = () => nodeParentPointer.value;
+  return childItem;
+});
+const makeChildrenItem = (item) => {
+  if (item === null || item === void 0 || item === false) {
+    return { type: null };
+  } else if (Array.isArray(item)) {
+    const nodeParentPointer = { value: void 0 };
+    const children = remakeChildren(nodeParentPointer, item);
+    const node = {
+      type: "loop",
+      children
+    };
+    nodeParentPointer.value = node;
+    return node;
+  } else if (typeof item === "string" || typeof item === "number") {
+    return { type: "text", text: item };
+  }
+  return item;
+};
+const ref = (initValue) => ({ value: initValue });
+const ext = {
+  componentRef,
+  componentKeyRef,
+  dataStoreStore,
+  dataStoreRenderQueue,
+  checkFunction,
+  getComponentKey,
+  componentRender
+};
+export {
+  Fragment,
+  ext,
+  h,
+  mount,
+  mountCallback,
+  ref,
+  render,
+  updateCallback
+};
+//# sourceMappingURL=lithent.mjs.map