create-velto 1.0.1 → 1.0.2

package/templates/velto-ts/node_modules/.pnpm/@velto+runtime@1.0.0-beta.2/node_modules/@velto/runtime/dist/index.js

@@ -0,0 +1,622 @@
+'use strict';
+
+var shared = require('@velto/shared');
+var reactive = require('@velto/reactive');
+
+// src/utils/index.ts
+var toDisplayString = (val) => {
+  return shared.isString(val) ? val : val == null ? "" : shared.isArray(val) || shared.isObject(val) && (val.toString === Object.prototype.toString || !shared.isFunction(val.toString)) ? JSON.stringify(val, replacer, 2) : String(val);
+};
+var replacer = (_key, val) => {
+  if (shared.isMap(val)) {
+    return {
+      [`Map(${val.size})`]: [...val.entries()].reduce((entries, [key, val2]) => {
+        entries[`${key} =>`] = val2;
+        return entries;
+      }, {})
+    };
+  } else if (shared.isSet(val)) {
+    return {
+      [`Set(${val.size})`]: [...val.values()]
+    };
+  } else if (shared.isObject(val) && !shared.isArray(val) && !shared.isPlainObject(val)) {
+    return String(val);
+  }
+  return val;
+};
+
+// src/utils/index.ts
+function markRender(fn) {
+  const render = fn;
+  render.__isRender = true;
+  return render;
+}
+function isRender(express) {
+  return shared.isFunction(express) && express.__isRender;
+}
+function normalizeContainer(container) {
+  if (shared.isString(container)) {
+    return document.querySelector(container);
+  }
+  return container;
+}
+var LifecycleHooks = /* @__PURE__ */ ((LifecycleHooks2) => {
+  LifecycleHooks2["CREATED"] = "created";
+  LifecycleHooks2["BEFORE_MOUNT"] = "beforeMount";
+  LifecycleHooks2["MOUNTED"] = "mounted";
+  LifecycleHooks2["BEFORE_UPDATE"] = "beforeUpdate";
+  LifecycleHooks2["UPDATED"] = "updated";
+  LifecycleHooks2["BEFORE_DESTROY"] = "beforeDestroy";
+  LifecycleHooks2["DESTROYED"] = "destroyed";
+  return LifecycleHooks2;
+})(LifecycleHooks || {});
+var createHook = (lifecycle) => (hook, instance = exports.currentInstance) => {
+  if (!instance) {
+    return;
+  }
+  if (!shared.isArray(instance[lifecycle])) {
+    instance[lifecycle] = [];
+  }
+  instance[lifecycle]?.push(hook);
+};
+var callHook = (lifecycle, instance) => {
+  const hook = instance?.[lifecycle];
+  if (!hook) {
+    return;
+  }
+  if (shared.isArray(hook)) {
+    hook.forEach((h) => shared.callUnstableFunc(h));
+  } else {
+    shared.callUnstableFunc(hook);
+  }
+};
+var onCreated = createHook("created" /* CREATED */);
+var onBeforeMount = createHook("beforeMount" /* BEFORE_MOUNT */);
+var onMounted = createHook("mounted" /* MOUNTED */);
+var onBeforeUpdate = createHook("beforeUpdate" /* BEFORE_UPDATE */);
+var onUpdated = createHook("updated" /* UPDATED */);
+var onBeforeDestroy = createHook("beforeDestroy" /* BEFORE_DESTROY */);
+var onDestroyed = createHook("destroyed" /* DESTROYED */);
+var uid = 0;
+function getComponentInstance(type, props) {
+  return {
+    uid: uid++,
+    type,
+    props,
+    template: void 0,
+    target: void 0,
+    anchor: void 0,
+    isCreated: false,
+    isMounted: false,
+    ["created" /* CREATED */]: null,
+    ["beforeMount" /* BEFORE_MOUNT */]: null,
+    ["mounted" /* MOUNTED */]: null,
+    ["beforeUpdate" /* BEFORE_UPDATE */]: null,
+    ["updated" /* UPDATED */]: null,
+    ["beforeDestroy" /* BEFORE_DESTROY */]: null,
+    ["destroyed" /* DESTROYED */]: null
+  };
+}
+function component(type, props) {
+  const componentProps = shared.omit(props, ["ref"]);
+  let instance = getComponentInstance(type, componentProps);
+  if (!!props.ref) {
+    props.ref?.setValue?.(instance);
+  }
+  const fn = () => {
+    if (!instance.isMounted) {
+      if (!instance.isCreated) {
+        setCurrentInstance(instance);
+        const render = instance.type(instance.props);
+        instance.template = render();
+        instance.isCreated = true;
+        callHook("created" /* CREATED */, instance);
+      }
+      callHook("beforeMount" /* BEFORE_MOUNT */, instance);
+      instance.template.mount(instance.target, instance.anchor);
+      instance.isMounted = true;
+      callHook("mounted" /* MOUNTED */, instance);
+    } else if (!effect.active) {
+      callHook("beforeDestroy" /* BEFORE_DESTROY */, instance);
+      instance.template.destroy();
+      instance = getComponentInstance(type, instance.props);
+      callHook("destroyed" /* DESTROYED */, instance);
+    } else {
+      callHook("beforeUpdate" /* BEFORE_UPDATE */, instance);
+      instance.template.update();
+      callHook("updated" /* UPDATED */, instance);
+    }
+  };
+  const scheduler = () => {
+    effect.run();
+  };
+  scheduler.id = instance.uid;
+  const effect = new reactive.Effect(fn, scheduler);
+  return {
+    mount(target, anchor) {
+      instance.target = target;
+      instance.anchor = anchor;
+      effect.run();
+    },
+    destroy() {
+      effect.destroy();
+    }
+  };
+}
+exports.currentInstance = null;
+var setCurrentInstance = (instance) => {
+  exports.currentInstance = instance;
+};
+
+// src/dom/index.ts
+var svgNS = "http://www.w3.org/2000/svg";
+var doc = typeof document !== "undefined" ? document : null;
+var append = (parent, child, anchor) => {
+  if (anchor) {
+    return insert(parent, child, anchor);
+  }
+  parent.appendChild(child);
+};
+var insert = (parent, child, anchor) => {
+  parent.insertBefore(child, anchor || null);
+};
+var remove = (child) => {
+  const parent = child.parentNode;
+  if (parent) {
+    parent.removeChild(child);
+  }
+};
+var createElement = (tag, isSVG, is) => {
+  const el = isSVG ? doc.createElementNS(svgNS, tag) : doc.createElement(tag, is ? { is } : void 0);
+  return el;
+};
+var text = (text2) => doc.createTextNode(text2);
+var comment = (text2) => doc.createComment(text2);
+var setText = (node, text2) => {
+  node.nodeValue = text2;
+};
+var setElementText = (el, text2) => {
+  el.textContent = text2;
+};
+var parentNode = (node) => node.parentNode;
+var nextSibling = (node) => node.nextSibling;
+var querySelector = (selector) => doc.querySelector(selector);
+
+// src/element/attribute/class.ts
+function classe(el, value, isSVG) {
+  if (value == null) {
+    el.removeAttribute("class");
+  } else if (isSVG) {
+    el.setAttribute("class", value);
+  } else {
+    el.className = value;
+  }
+}
+function style(el, value) {
+  if (!value) {
+    return el.removeAttribute("style");
+  }
+  const style2 = el.style;
+  if (shared.isString(value)) {
+    style2.cssText = value;
+  } else {
+    for (const key in value) {
+      resolveStyle(style2, key, value[key]);
+    }
+  }
+}
+function resolveStyle(style2, name, val) {
+  if (shared.isArray(val)) {
+    val.forEach((v) => resolveStyle(style2, name, v));
+  } else {
+    if (val == null) val = "";
+    if (name.startsWith("--")) {
+      style2.setProperty(name, val);
+    } else {
+      const prefixed = autoPrefix(style2, name);
+      const importantRE = /\s*!important$/;
+      if (importantRE.test(val)) {
+        style2.setProperty(
+          shared.hyphenate(prefixed),
+          val.replace(importantRE, ""),
+          "important"
+        );
+      } else {
+        style2[prefixed] = val;
+      }
+    }
+  }
+}
+var prefixCache = {};
+function autoPrefix(style2, rawName) {
+  const prefixes = ["Webkit", "Moz", "ms"];
+  const cached = prefixCache[rawName];
+  if (cached) {
+    return cached;
+  }
+  let name = shared.camelize(rawName);
+  if (name !== "filter" && name in style2) {
+    return prefixCache[rawName] = name;
+  }
+  name = shared.capitalize(name);
+  for (let i = 0; i < prefixes.length; i++) {
+    const prefixed = prefixes[i] + name;
+    if (prefixed in style2) {
+      return prefixCache[rawName] = prefixed;
+    }
+  }
+  return rawName;
+}
+
+// src/element/attribute/events.ts
+var eventListenerMap = /* @__PURE__ */ new WeakMap();
+function event(el, eventName, value, options) {
+  let elEventMap = eventListenerMap.get(el);
+  if (!elEventMap) {
+    elEventMap = {};
+    eventListenerMap.set(el, elEventMap);
+  }
+  const oldEventValue = elEventMap[eventName];
+  if (oldEventValue === value) {
+    return;
+  }
+  const name = eventName.slice(2).toLocaleLowerCase();
+  if (value) {
+    addEventListener(el, name, value, options);
+    elEventMap[eventName] = value;
+  } else if (oldEventValue) {
+    removeEventListener(el, name, oldEventValue, options);
+    delete elEventMap[eventName];
+  }
+}
+function addEventListener(el, event2, handler, options) {
+  el.addEventListener(event2, handler, options);
+}
+function removeEventListener(el, event2, handler, options) {
+  el.removeEventListener(event2, handler, options);
+}
+var xlinkNS = "http://www.w3.org/1999/xlink";
+function attr(el, key, value, isSVG) {
+  if (isSVG && key.startsWith("xlink:")) {
+    if (value == null) {
+      el.removeAttributeNS(xlinkNS, key.slice(6, key.length));
+    } else {
+      el.setAttributeNS(xlinkNS, key, value);
+    }
+  } else {
+    const isBoolean = shared.isBooleanAttribute(key);
+    if (value == null || isBoolean && !(value || value === "")) {
+      el.removeAttribute(key);
+    } else {
+      el.setAttribute(key, isBoolean ? "" : value);
+    }
+  }
+}
+var setAttribute = (el, key, value, isSVG = false) => {
+  if (key === "ref") {
+    value?.setValue?.(el);
+  } else if (key === "class") {
+    classe(el, value, isSVG);
+  } else if (key === "style") {
+    style(el, value);
+  } else if (shared.isEvent(key)) {
+    event(el, key, value);
+  } else {
+    attr(el, key, value, isSVG);
+  }
+};
+function element(tag, props) {
+  const el = createElement(tag);
+  return {
+    el,
+    mount: (target, anchor) => {
+      append(target, el, anchor);
+      for (let attr2 in props) {
+        setAttribute(el, attr2, props[attr2]);
+      }
+    },
+    update(newProps) {
+      for (let attr2 in newProps) {
+        if (newProps[attr2] !== props?.[attr2]) {
+          setAttribute(el, attr2, newProps[attr2]);
+        }
+      }
+      props = newProps;
+    },
+    destroy() {
+      remove(el);
+    }
+  };
+}
+
+// src/expression/index.ts
+function expression(express) {
+  if (isRender(express)) return express();
+  let cacheTarget;
+  let cacheAnchor;
+  let node;
+  const update = (express2) => {
+    const content = toDisplayString(express2);
+    if (!node) {
+      node = text(content);
+      insert(cacheTarget, node, cacheAnchor);
+    } else {
+      node.nodeValue = content;
+    }
+  };
+  return {
+    mount: (target, anchor) => {
+      cacheTarget = target;
+      cacheAnchor = anchor;
+      update(express);
+    },
+    update(newExpress) {
+      if (express !== newExpress) {
+        update(newExpress);
+      }
+      express = newExpress;
+    },
+    destroy: () => {
+      if (node) {
+        remove(node);
+        node = void 0;
+      }
+    }
+  };
+}
+
+// src/renderList/index.ts
+function renderList(list = [], renderCallback) {
+  let cacheTarget;
+  const cached = [];
+  const create = (options) => {
+    const { list: list2, index, anchor } = options;
+    const item = list2[index];
+    const render = renderCallback(item, index, list2);
+    const template = render();
+    template.mount(cacheTarget, anchor);
+    cached[index] = {
+      template,
+      anchor,
+      item
+    };
+  };
+  return markRender(() => ({
+    mount: (target, anchor) => {
+      cacheTarget = target;
+      list.forEach((_, index) => {
+        const itemAnchor = text("");
+        append(target, itemAnchor, anchor);
+        create({ list, index, anchor: itemAnchor });
+      });
+    },
+    update(newList) {
+      const newLength = newList.length;
+      const cachedLength = cached.length;
+      const needAddCachedLength = newLength - cachedLength;
+      let i = 0;
+      let e = 0;
+      while (i < newLength && i < cachedLength) {
+        const cachedItem = cached[i];
+        const item = newList[i];
+        if (cachedItem.item === item) {
+          cachedItem.template.update();
+          i++;
+        } else {
+          break;
+        }
+      }
+      while (e < newLength && e < cachedLength) {
+        const cachedItem = cached[cachedLength - e - 1];
+        const item = newList[newLength - e - 1];
+        if (cachedItem.item === item) {
+          cachedItem.template.update();
+          e++;
+        } else {
+          break;
+        }
+      }
+      let newListPreIndex = i - 1;
+      let cachedPreIndex = i - 1;
+      let newListEndIndex = newLength - e;
+      let cachedEndIndex = cachedLength - e;
+      const newCached = cached;
+      if (needAddCachedLength > 0) {
+        newCached.splice(cachedEndIndex, 0, ...Array.from({ length: needAddCachedLength }));
+        for (newListPreIndex++; newListPreIndex < newListEndIndex; newListPreIndex++) {
+          const cachedItem = newCached[newListPreIndex];
+          if (cachedItem) {
+            cachedItem.template.update();
+          } else {
+            const preItemCached = newCached[newListPreIndex - 1];
+            const itemAnchor = text("");
+            if (preItemCached) {
+              insert(cacheTarget, itemAnchor, preItemCached.anchor.nextSibling);
+            } else {
+              insert(cacheTarget, itemAnchor, cacheTarget.firstChild);
+            }
+            create({ list: newList, index: newListPreIndex, anchor: itemAnchor });
+          }
+        }
+      } else if (needAddCachedLength < 0) {
+        let startIndex = -1;
+        let destroyCount = 0;
+        for (cachedPreIndex++; cachedPreIndex < cachedEndIndex; cachedPreIndex++) {
+          const cachedItem = newCached[cachedPreIndex];
+          if (cachedPreIndex < newListEndIndex) {
+            cachedItem.template.update();
+          } else {
+            cachedItem.template.destroy();
+            remove(cachedItem.anchor);
+            if (startIndex === -1) {
+              startIndex = cachedPreIndex;
+            }
+            destroyCount++;
+          }
+        }
+        if (destroyCount) {
+          newCached.splice(startIndex, destroyCount);
+        }
+      }
+    },
+    destroy() {
+      cached.forEach((item) => {
+        item.template.destroy();
+      });
+      cached.length = 0;
+    }
+  }));
+}
+
+// src/condition/index.ts
+function condition(template, initCondition) {
+  let cacheTarget;
+  let cacheAnchor;
+  return {
+    mount: (target, anchor) => {
+      cacheTarget = target;
+      cacheAnchor = text(" ");
+      append(target, cacheAnchor);
+      initCondition && template.mount(target, cacheAnchor);
+    },
+    update(newCondition, newExpress) {
+      if (newCondition !== initCondition) {
+        newCondition ? template.mount(cacheTarget, cacheAnchor) : template.destroy();
+      } else {
+        newCondition ? template.update(newExpress) : template.destroy();
+      }
+      initCondition = newCondition;
+    },
+    destroy: () => {
+      template.destroy();
+    }
+  };
+}
+function defineAsyncComponent(source) {
+  if (shared.isFunction(source)) {
+    source = { loader: source };
+  }
+  const {
+    loader,
+    loadingComponent,
+    errorComponent,
+    timeout
+  } = source;
+  let retries = 0;
+  let componentTemplate;
+  let props = {};
+  let cacheTarget;
+  const cacheAnchor = text(" ");
+  const renderComponent = (currentComponent, props2 = {}) => {
+    componentTemplate?.destroy();
+    if (currentComponent) {
+      const componentRender = currentComponent(props2);
+      componentTemplate = componentRender?.();
+      componentTemplate?.mount(cacheTarget, cacheAnchor);
+    }
+  };
+  const retry = async () => {
+    retries++;
+    renderComponent(loadingComponent, props);
+    await load();
+  };
+  const load = async () => {
+    let loadingPromise = new Promise((resolve, reject) => {
+      loader().then(resolve).catch(reject);
+      if (timeout) {
+        setTimeout(() => {
+          const err = new Error(
+            `Async component timed out after ${timeout}ms.`
+          );
+          reject(err);
+        }, timeout);
+      }
+    });
+    return loadingPromise.then((compModule) => {
+      if (shared.isFunction(compModule?.default) && (compModule?.__esModule || compModule?.[Symbol.toStringTag] === "Module")) {
+        compModule = compModule.default;
+      }
+      return compModule;
+    }).then((comp) => {
+      renderComponent(comp, props);
+    }).catch((err) => {
+      renderComponent(errorComponent, {
+        props,
+        err: err instanceof Error ? err : new Error(String(err)),
+        retry,
+        retries
+      });
+    });
+  };
+  return (init) => {
+    props = init;
+    return markRender(() => ({
+      mount: (target, anchor) => {
+        cacheTarget = target;
+        append(target, cacheAnchor);
+        renderComponent(loadingComponent, props), load();
+      },
+      update() {
+        componentTemplate?.update();
+      },
+      destroy() {
+        componentTemplate?.destroy();
+      }
+    }));
+  };
+}
+
+// src/index.ts
+function createApp(type, containerOrSelector, init = {}) {
+  const container = normalizeContainer(containerOrSelector);
+  if (container) {
+    container.innerHTML = "";
+    component(type, init).mount(container);
+  }
+}
+
+exports.LifecycleHooks = LifecycleHooks;
+exports.append = append;
+exports.attr = attr;
+exports.callHook = callHook;
+exports.classe = classe;
+exports.comment = comment;
+exports.component = component;
+exports.condition = condition;
+exports.createApp = createApp;
+exports.createElement = createElement;
+exports.createHook = createHook;
+exports.defineAsyncComponent = defineAsyncComponent;
+exports.element = element;
+exports.event = event;
+exports.expression = expression;
+exports.getComponentInstance = getComponentInstance;
+exports.insert = insert;
+exports.markRender = markRender;
+exports.nextSibling = nextSibling;
+exports.onBeforeDestroy = onBeforeDestroy;
+exports.onBeforeMount = onBeforeMount;
+exports.onBeforeUpdate = onBeforeUpdate;
+exports.onCreated = onCreated;
+exports.onDestroyed = onDestroyed;
+exports.onMounted = onMounted;
+exports.onUpdated = onUpdated;
+exports.parentNode = parentNode;
+exports.querySelector = querySelector;
+exports.remove = remove;
+exports.renderList = renderList;
+exports.setAttribute = setAttribute;
+exports.setCurrentInstance = setCurrentInstance;
+exports.setElementText = setElementText;
+exports.setText = setText;
+exports.style = style;
+exports.svgNS = svgNS;
+exports.text = text;
+Object.keys(reactive).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return reactive[k]; }
+  });
+});
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map