@jay-framework/runtime 0.5.0

package/dist/index.js

@@ -0,0 +1,836 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import { RandomAccessLinkedList, listCompare, ITEM_ADDED, ITEM_REMOVED } from "@jay-framework/list-compare";
+class KindergartenGroup {
+  constructor(kindergarten) {
+    __publicField(this, "kindergarten");
+    __publicField(this, "groupListener");
+    __publicField(this, "children");
+    this.kindergarten = kindergarten;
+    this.children = /* @__PURE__ */ new Set();
+  }
+  addListener(groupListener) {
+    this.groupListener = groupListener;
+  }
+  ensureNode(node, atIndex) {
+    atIndex = atIndex || 0;
+    atIndex = atIndex < 0 ? this.children.size + 1 + atIndex : atIndex;
+    let offset = this.kindergarten.getOffsetFor(this);
+    if (this.kindergarten.parentNode.childNodes.length > offset + atIndex)
+      this.kindergarten.parentNode.insertBefore(
+        node,
+        this.kindergarten.parentNode.childNodes[offset + atIndex]
+      );
+    else {
+      this.kindergarten.parentNode.appendChild(node);
+    }
+    this.children.add(node);
+    if (this.groupListener)
+      this.groupListener.addNode(node);
+  }
+  removeNode(node) {
+    if (this.children.has(node)) {
+      this.kindergarten.parentNode.removeChild(node);
+      this.children.delete(node);
+      if (this.groupListener)
+        this.groupListener.removeNode(node);
+    }
+  }
+  removeNodeAt(pos) {
+    let offset = this.kindergarten.getOffsetFor(this);
+    this.removeNode(this.kindergarten.parentNode.childNodes[offset + pos]);
+  }
+  moveNode(from, to) {
+    let offset = this.kindergarten.getOffsetFor(this);
+    let nodeToMove = this.kindergarten.parentNode.childNodes[offset + from];
+    if (to > from)
+      to += 1;
+    if (this.kindergarten.parentNode.childNodes.length > offset + to)
+      this.kindergarten.parentNode.insertBefore(
+        nodeToMove,
+        this.kindergarten.parentNode.childNodes[offset + to]
+      );
+    else {
+      this.kindergarten.parentNode.appendChild(nodeToMove);
+    }
+  }
+}
+class Kindergarten {
+  constructor(parentNode) {
+    __publicField(this, "parentNode");
+    __publicField(this, "groups", []);
+    this.parentNode = parentNode;
+  }
+  newGroup() {
+    let kindergartenGroup = new KindergartenGroup(this);
+    this.groups.push(kindergartenGroup);
+    return kindergartenGroup;
+  }
+  getOffsetFor(group) {
+    let index = 0;
+    let offset = 0;
+    while (index < this.groups.length && this.groups[index] !== group) {
+      offset += this.groups[index].children.size;
+      index = index + 1;
+    }
+    return offset;
+  }
+}
+const noopUpdate = (_newData) => {
+};
+const noopMount = () => {
+};
+let currentContext = void 0;
+function NewContextStack(context, marker, parent) {
+  return { context, marker, parent };
+}
+function createJayContext() {
+  return Symbol();
+}
+function withContext(marker, context, callback) {
+  let aContext = NewContextStack(context, marker, currentContext);
+  try {
+    currentContext = aContext;
+    return callback();
+  } finally {
+    currentContext = aContext.parent;
+  }
+}
+function useContext(marker) {
+  let context = findContext((_) => _ === marker);
+  if (!context)
+    throw new Error();
+  return context;
+}
+function findContext(predicate) {
+  let aContext = currentContext;
+  while (aContext) {
+    if (predicate(aContext.marker))
+      return aContext.context;
+    aContext = aContext.parent;
+  }
+  return void 0;
+}
+function saveContext() {
+  return currentContext;
+}
+function restoreContext(savedContext, callback) {
+  let aContext = currentContext;
+  try {
+    currentContext = savedContext;
+    return callback();
+  } finally {
+    currentContext = aContext;
+  }
+}
+const CONSTRUCTION_CONTEXT_MARKER = createJayContext();
+function currentConstructionContext() {
+  return useContext(CONSTRUCTION_CONTEXT_MARKER);
+}
+function wrapWithModifiedCheck(initialData, baseJayElement) {
+  let update = baseJayElement.update;
+  let current = initialData;
+  baseJayElement.update = (newData) => {
+    let isModified = newData !== current;
+    current = newData;
+    if (isModified)
+      update(current);
+  };
+  return baseJayElement;
+}
+class ConstructContext {
+  constructor(data, forStaticElements = true, coordinateBase = []) {
+    __publicField(this, "coordinate", (refName) => {
+      return [...this.coordinateBase, refName];
+    });
+    this.data = data;
+    this.forStaticElements = forStaticElements;
+    this.coordinateBase = coordinateBase;
+  }
+  get currData() {
+    return this.data;
+  }
+  forItem(childViewState, id) {
+    return new ConstructContext(childViewState, false, [...this.coordinateBase, id]);
+  }
+  static withRootContext(viewState, refManager, elementConstructor) {
+    let context = new ConstructContext(viewState);
+    let element2 = withContext(
+      CONSTRUCTION_CONTEXT_MARKER,
+      context,
+      () => wrapWithModifiedCheck(currentConstructionContext().currData, elementConstructor())
+    );
+    element2.mount();
+    return refManager.applyToElement(element2);
+  }
+}
+const STYLE = "style";
+function mkRef(ref, referenced, updates, mounts, unmounts) {
+  updates.push(ref.update);
+  ref.set(referenced);
+  mounts.push(ref.mount);
+  unmounts.push(ref.unmount);
+}
+function childComp(compCreator, getProps, ref) {
+  let context = currentConstructionContext();
+  let childComp2 = compCreator(getProps(context.currData));
+  let updates = [(t) => childComp2.update(getProps(t))];
+  let mounts = [childComp2.mount];
+  let unmounts = [childComp2.unmount];
+  if (ref) {
+    mkRef(ref, childComp2, updates, mounts, unmounts);
+  }
+  return {
+    dom: childComp2.element.dom,
+    update: normalizeUpdates(updates),
+    mount: normalizeMount(mounts),
+    unmount: normalizeMount(unmounts)
+  };
+}
+const PROPERTY = 1, ATTRIBUTE = 2, BOOLEAN_ATTRIBUTE = 3;
+function isDynamicAttributeOrProperty(value) {
+  return typeof value.valueFunc === "function";
+}
+function dynamicAttribute(attributeValue) {
+  return { valueFunc: attributeValue, style: ATTRIBUTE };
+}
+function dynamicProperty(propertyValue) {
+  return { valueFunc: propertyValue, style: PROPERTY };
+}
+function booleanAttribute(propertyValue) {
+  return { valueFunc: propertyValue, style: BOOLEAN_ATTRIBUTE };
+}
+function doSetAttribute(target, key, value, attributeStyle) {
+  const isHTMLElement = target instanceof Element;
+  if (isHTMLElement && attributeStyle === ATTRIBUTE) {
+    target.setAttribute(key, value);
+  } else if (isHTMLElement && attributeStyle === BOOLEAN_ATTRIBUTE) {
+    if (value)
+      target.setAttribute(key, value);
+    else
+      target.removeAttribute(key);
+  } else
+    target[key] = value;
+}
+function setAttribute(target, key, value, updates) {
+  if (isDynamicAttributeOrProperty(value)) {
+    let context = currentConstructionContext();
+    let attributeValue = value.valueFunc(context.currData);
+    doSetAttribute(target, key, attributeValue, value.style);
+    updates.push((newData) => {
+      let newAttributeValue = value.valueFunc(newData);
+      if (newAttributeValue !== attributeValue)
+        doSetAttribute(target, key, newAttributeValue, value.style);
+      attributeValue = newAttributeValue;
+    });
+  } else
+    doSetAttribute(target, key, value, ATTRIBUTE);
+}
+function conditional(condition, elem) {
+  return {
+    condition,
+    elem: () => {
+      const createdElem = elem();
+      return typeof createdElem === "string" ? text(createdElem) : createdElem;
+    }
+  };
+}
+function isCondition(c) {
+  return c.condition !== void 0;
+}
+function isForEach(c) {
+  return c.elemCreator !== void 0;
+}
+function forEach(getItems, elemCreator, matchBy) {
+  return { getItems, elemCreator, trackBy: matchBy };
+}
+function applyListChanges(group, instructions) {
+  instructions.forEach((instruction) => {
+    if (instruction.action === ITEM_ADDED) {
+      group.ensureNode(instruction.elem.dom, instruction.pos);
+      instruction.elem.mount();
+    } else if (instruction.action === ITEM_REMOVED) {
+      group.removeNodeAt(instruction.pos);
+      instruction.elem.unmount();
+    } else {
+      group.moveNode(instruction.fromPos, instruction.pos);
+    }
+  });
+}
+function mkUpdateCollection(child, group) {
+  let lastItems = [];
+  let lastItemsList = new RandomAccessLinkedList([], child.trackBy);
+  let mount = () => lastItemsList.forEach((value, attach) => attach.mount);
+  let unmount = () => lastItemsList.forEach((value, attach) => attach.unmount);
+  let parentContext = currentConstructionContext();
+  let savedContext = saveContext();
+  const update = (newData) => {
+    const items = child.getItems(newData) || [];
+    let isModified = items !== lastItems;
+    lastItems = items;
+    if (isModified) {
+      let itemsList = new RandomAccessLinkedList(items, child.trackBy);
+      let instructions = listCompare(
+        lastItemsList,
+        itemsList,
+        (item, id) => {
+          let childContext = parentContext.forItem(item, id);
+          return restoreContext(
+            savedContext,
+            () => withContext(
+              CONSTRUCTION_CONTEXT_MARKER,
+              childContext,
+              () => wrapWithModifiedCheck(
+                currentConstructionContext().currData,
+                child.elemCreator(item, id)
+              )
+            )
+          );
+        }
+      );
+      lastItemsList = itemsList;
+      applyListChanges(group, instructions);
+      itemsList.forEach((value, elem) => elem.update(value));
+    }
+  };
+  return [update, mount, unmount];
+}
+function mkUpdateCondition(child, group) {
+  let mount = noopMount, unmount = noopMount;
+  let lastResult = false;
+  let childElement = void 0;
+  const update = (newData) => {
+    if (!childElement) {
+      childElement = child.elem();
+      mount = () => lastResult && childElement.mount();
+      unmount = () => childElement.unmount();
+    }
+    let result = child.condition(newData);
+    if (result) {
+      if (!lastResult) {
+        group.ensureNode(childElement.dom);
+        childElement.mount();
+      }
+      childElement.update(newData);
+    } else if (lastResult) {
+      group.removeNode(childElement.dom);
+      childElement.unmount();
+    }
+    lastResult = result;
+  };
+  return [update, mount, unmount];
+}
+function text(content) {
+  return {
+    dom: document.createTextNode(content),
+    update: noopUpdate,
+    mount: noopMount,
+    unmount: noopMount
+  };
+}
+function dynamicText(textContent) {
+  let context = currentConstructionContext();
+  let content = textContent(context.currData);
+  let n = document.createTextNode(content);
+  return {
+    dom: n,
+    update: (newData) => {
+      let newContent = textContent(newData);
+      if (newContent !== content)
+        n.textContent = newContent;
+      content = newContent;
+    },
+    mount: noopMount,
+    unmount: noopMount
+  };
+}
+const elementNS = (ns) => (tagName, attributes, children = [], ref) => {
+  let { e, updates, mounts, unmounts } = createBaseElement(ns, tagName, attributes, ref);
+  children.forEach((child) => {
+    if (typeof child === "string")
+      child = text(child);
+    e.append(child.dom);
+    if (child.update !== noopUpdate)
+      updates.push(child.update);
+    if (child.mount !== noopMount) {
+      mounts.push(child.mount);
+      unmounts.push(child.unmount);
+    }
+  });
+  return {
+    dom: e,
+    update: normalizeUpdates(updates),
+    mount: normalizeMount(mounts),
+    unmount: normalizeMount(unmounts)
+  };
+};
+const HTML = "http://www.w3.org/1999/xhtml";
+const SVG = "http://www.w3.org/2000/svg";
+const MathML = "http://www.w3.org/1998/Math/MathML";
+const element = elementNS(HTML);
+const svgElement = elementNS(SVG);
+const mathMLElement = elementNS(MathML);
+const dynamicElementNS = (ns) => (tagName, attributes, children = [], ref) => {
+  let { e, updates, mounts, unmounts } = createBaseElement(ns, tagName, attributes, ref);
+  let kindergarten = new Kindergarten(e);
+  children.forEach((child) => {
+    if (typeof child === "string")
+      child = text(child);
+    let group = kindergarten.newGroup();
+    let update = noopUpdate, mount = noopMount, unmount = noopMount;
+    if (isCondition(child)) {
+      [update, mount, unmount] = mkUpdateCondition(child, group);
+    } else if (isForEach(child)) {
+      [update, mount, unmount] = mkUpdateCollection(child, group);
+    } else {
+      group.ensureNode(child.dom);
+      if (child.update !== noopUpdate)
+        update = child.update;
+      if (child.mount !== noopMount) {
+        mount = child.mount;
+        unmount = child.unmount;
+      }
+    }
+    if (update !== noopUpdate) {
+      let context = currentConstructionContext();
+      update(context.currData);
+      updates.push(update);
+    }
+    if (mount !== noopMount) {
+      mounts.push(mount);
+      unmounts.push(unmount);
+    }
+  });
+  return {
+    dom: e,
+    update: normalizeUpdates(updates),
+    mount: normalizeMount(mounts),
+    unmount: normalizeMount(unmounts)
+  };
+};
+const dynamicElement = dynamicElementNS(HTML);
+const svgDynamicElement = dynamicElementNS(SVG);
+const mathMLDynamicElement = dynamicElementNS(MathML);
+function createBaseElement(ns, tagName, attributes, ref) {
+  let e = document.createElementNS(ns, tagName);
+  let updates = [];
+  let mounts = [];
+  let unmounts = [];
+  if (ref)
+    mkRef(ref, e, updates, mounts, unmounts);
+  Object.entries(attributes).forEach(([key, value]) => {
+    if (key === STYLE && e instanceof HTMLElement) {
+      Object.entries(value).forEach(([styleKey, styleValue]) => {
+        setAttribute(
+          e.style,
+          styleKey,
+          styleValue,
+          updates
+        );
+      });
+    } else {
+      setAttribute(
+        e,
+        key,
+        value,
+        updates
+      );
+    }
+  });
+  return { e, updates, mounts, unmounts };
+}
+function normalizeUpdates(updates) {
+  if (updates.length === 1)
+    return updates[0];
+  else if (updates.length > 0) {
+    for (let i = updates.length - 1; i >= 0; i--) {
+      if (updates[i]._origUpdates)
+        updates.splice(i, 1, ...updates[i]._origUpdates);
+    }
+    let updateFunc2 = (newData) => {
+      updates.forEach((updateFn) => updateFn(newData));
+    };
+    updateFunc2._origUpdates = updates;
+    return updateFunc2;
+  } else {
+    return noopUpdate;
+  }
+}
+function normalizeMount(mounts) {
+  if (mounts.length === 1)
+    return mounts[0];
+  else if (mounts.length > 0) {
+    return () => {
+      mounts.forEach((updateFn) => updateFn());
+    };
+  } else {
+    return noopMount;
+  }
+}
+class PrivateRefs {
+  constructor() {
+    __publicField(this, "elements", /* @__PURE__ */ new Set());
+    __publicField(this, "listeners", []);
+  }
+  addEventListener(type, listener, options) {
+    this.listeners.push({ type, listener, options });
+    this.elements.forEach((ref) => ref.addEventListener(type, listener, options));
+  }
+  addRef(ref) {
+    if (!this.elements.has(ref)) {
+      this.elements.add(ref);
+      this.listeners.forEach(
+        (listener) => ref.addEventListener(listener.type, listener.listener, listener.options)
+      );
+    }
+  }
+  removeRef(ref) {
+    this.elements.delete(ref);
+    this.listeners.forEach(
+      (listener) => ref.removeEventListener(listener.type, listener.listener, listener.options)
+    );
+  }
+  removeEventListener(type, listener, options) {
+    this.listeners = this.listeners.filter(
+      (item) => item.type !== type || item.listener !== listener
+    );
+    this.elements.forEach((ref) => ref.removeEventListener(type, listener, options));
+  }
+}
+class PrivateCollectionRefs extends PrivateRefs {
+  map(handler) {
+    return [...this.elements].map(
+      (ref) => handler(ref.getPublicAPI(), ref.viewState, ref.coordinate)
+    );
+  }
+  find(predicate) {
+    for (let ref of this.elements)
+      if (predicate(ref.viewState, ref.coordinate))
+        return ref.getPublicAPI();
+  }
+}
+class HTMLElementCollectionRefImpl extends PrivateCollectionRefs {
+  mkManagedRef(currData, coordinate, eventWrapper) {
+    return new HTMLElementRefImpl(
+      currData,
+      coordinate,
+      eventWrapper,
+      this
+    );
+  }
+  getPublicAPI() {
+    return newHTMLElementPublicApiProxy(this);
+  }
+}
+class HTMLElementRefsImpl extends PrivateRefs {
+  mkManagedRef(currData, coordinate, eventWrapper) {
+    return new HTMLElementRefImpl(
+      currData,
+      coordinate,
+      eventWrapper,
+      this
+    );
+  }
+  getPublicAPI() {
+    return newHTMLElementPublicApiProxy(this);
+  }
+  exec$(handler) {
+    return [...this.elements][0].exec$(handler);
+  }
+}
+class ComponentRefsImpl extends PrivateRefs {
+  getInstance() {
+    return [...this.elements][0]?.getPublicAPI();
+  }
+  mkManagedRef(currData, coordinate, eventWrapper) {
+    return new ComponentRefImpl(
+      currData,
+      coordinate,
+      eventWrapper,
+      this
+    );
+  }
+  getPublicAPI() {
+    return newComponentPublicApiProxy(this);
+  }
+}
+class ComponentCollectionRefImpl extends PrivateCollectionRefs {
+  mkManagedRef(currData, coordinate, eventWrapper) {
+    return new ComponentRefImpl(
+      currData,
+      coordinate,
+      eventWrapper,
+      this
+    );
+  }
+  getPublicAPI() {
+    return newComponentCollectionPublicApiProxy(this);
+  }
+}
+class RefImpl {
+  constructor(viewState, coordinate, eventWrapper, parentCollection) {
+    __publicField(this, "listeners", []);
+    __publicField(this, "element");
+    __publicField(this, "mount", () => {
+      this.parentCollection?.addRef(this);
+    });
+    __publicField(this, "unmount", () => {
+      this.parentCollection?.removeRef(this);
+    });
+    __publicField(this, "update", (newData) => {
+      this.viewState = newData;
+    });
+    this.viewState = viewState;
+    this.coordinate = coordinate;
+    this.eventWrapper = eventWrapper;
+    this.parentCollection = parentCollection;
+    this.viewState = viewState;
+  }
+  set(referenced) {
+    this.element = referenced;
+    this.listeners.forEach(
+      ({ type, wrappedHandler, options }) => this.element.addEventListener(type, wrappedHandler, options)
+    );
+  }
+  addEventListener(type, listener, options) {
+    let wrappedHandler = (event) => {
+      return this.eventWrapper(listener, this.formatEvent(event));
+    };
+    this.element?.addEventListener(type, wrappedHandler, options);
+    this.listeners.push({ type, listener, wrappedHandler, options });
+  }
+  removeEventListener(type, listener, options) {
+    let index = this.listeners.findIndex(
+      (item) => item.type === type && item.listener === listener
+    );
+    if (index > -1) {
+      let item = this.listeners[index];
+      this.listeners.splice(index, 1);
+      this.element?.removeEventListener(type, item.wrappedHandler, options);
+    }
+  }
+}
+class HTMLElementRefImpl extends RefImpl {
+  formatEvent(event) {
+    return { event, viewState: this.viewState, coordinate: this.coordinate };
+  }
+  getPublicAPI() {
+    return newHTMLElementPublicApiProxy(this);
+  }
+  exec$(handler) {
+    return new Promise((resolve, reject) => {
+      try {
+        resolve(handler(this.element, this.viewState));
+      } catch (e) {
+        reject(e);
+      }
+    });
+  }
+}
+class ComponentRefImpl extends RefImpl {
+  getFromComponent(prop) {
+    return this.element[prop];
+  }
+  formatEvent(event) {
+    return { ...event, viewState: this.viewState, coordinate: this.coordinate };
+  }
+  getPublicAPI() {
+    return newComponentInCollectionPublicApiProxy(
+      this
+    );
+  }
+}
+const EVENT_TRAP = (target, prop) => {
+  if (typeof prop === "string") {
+    if (prop.indexOf("on") === 0) {
+      let eventName = prop.substring(2);
+      return (handler) => {
+        target.addEventListener(eventName, handler);
+      };
+    }
+    if (prop === "addEventListener")
+      return target.addEventListener.bind(target);
+  }
+  return false;
+};
+const EVENT$_TRAP = (target, prop) => {
+  if (typeof prop === "string") {
+    if (prop.indexOf("on") === 0 && prop.at(-1) === "$") {
+      let eventName = prop.slice(2, -1);
+      return (nativeHandler) => {
+        let regularHandler;
+        const handler = ({ event, viewState, coordinate }) => {
+          const returnedEvent = nativeHandler({ event, viewState, coordinate });
+          if (regularHandler)
+            regularHandler({ event: returnedEvent, viewState, coordinate });
+        };
+        target.addEventListener(eventName, handler);
+        return {
+          then: (handler2) => {
+            regularHandler = handler2;
+          }
+        };
+      };
+    }
+  }
+  return false;
+};
+const DELEGATE_REF_TO_COMP_TRAP = (target, prop) => {
+  return target.getFromComponent(prop);
+};
+const DELEGATE_REFS_TO_COMP_TRAP = (target, prop) => {
+  const instance = target.getInstance();
+  return instance ? instance[prop] : void 0;
+};
+const GetTrapProxy = (getTraps) => {
+  return {
+    get: function(target, prop, receiver) {
+      let result;
+      for (let getTrap of getTraps) {
+        result = getTrap(target, prop, receiver);
+        if (result)
+          return result;
+      }
+      return target[prop];
+    }
+  };
+};
+const HTMLElementRefProxy = GetTrapProxy([EVENT$_TRAP, EVENT_TRAP]);
+function newHTMLElementPublicApiProxy(ref) {
+  return new Proxy(ref, HTMLElementRefProxy);
+}
+const ComponentRefProxy = GetTrapProxy([EVENT_TRAP, DELEGATE_REFS_TO_COMP_TRAP]);
+function newComponentPublicApiProxy(ref) {
+  return new Proxy(ref, ComponentRefProxy);
+}
+const ComponentInCollectionRefProxy = GetTrapProxy([EVENT_TRAP, DELEGATE_REF_TO_COMP_TRAP]);
+function newComponentInCollectionPublicApiProxy(ref) {
+  return new Proxy(ref, ComponentInCollectionRefProxy);
+}
+const ComponentCollectionRefProxy = GetTrapProxy([EVENT_TRAP]);
+function newComponentCollectionPublicApiProxy(ref) {
+  return new Proxy(ref, ComponentCollectionRefProxy);
+}
+function defaultEventWrapper(orig, event) {
+  return orig(event);
+}
+var ManagedRefType = /* @__PURE__ */ ((ManagedRefType2) => {
+  ManagedRefType2[ManagedRefType2["element"] = 0] = "element";
+  ManagedRefType2[ManagedRefType2["elementCollection"] = 1] = "elementCollection";
+  ManagedRefType2[ManagedRefType2["component"] = 2] = "component";
+  ManagedRefType2[ManagedRefType2["componentCollection"] = 3] = "componentCollection";
+  return ManagedRefType2;
+})(ManagedRefType || {});
+class BaseReferencesManager {
+  constructor(eventWrapper = defaultEventWrapper) {
+    __publicField(this, "refs", {});
+    __publicField(this, "refsPublicAPI");
+    this.eventWrapper = eventWrapper;
+  }
+  mkRefsOfType(refType, refNames) {
+    return refNames.map((refName) => {
+      const managedRef = this.mkManagedRef(refType, refName);
+      this.refs[refName] = managedRef;
+      return () => {
+        let { currData, coordinate } = this.currentContext();
+        return managedRef.mkManagedRef(currData, coordinate(refName), this.eventWrapper);
+      };
+    });
+  }
+  mkRefs(elem, elemCollection, comp, compCollection, childRefManagers = {}) {
+    this.refs = childRefManagers;
+    return [
+      ...this.mkRefsOfType(0, elem),
+      ...this.mkRefsOfType(1, elemCollection),
+      ...this.mkRefsOfType(2, comp),
+      ...this.mkRefsOfType(3, compCollection)
+    ];
+  }
+  mkRefsPublicAPI() {
+    this.refsPublicAPI = Object.keys(this.refs).reduce((publicRefAPIs, key) => {
+      publicRefAPIs[key] = this.refs[key].getPublicAPI();
+      return publicRefAPIs;
+    }, {});
+  }
+  get(refName) {
+    return this.refs[refName];
+  }
+  getPublicAPI() {
+    if (!this.refsPublicAPI)
+      this.mkRefsPublicAPI();
+    return this.refsPublicAPI;
+  }
+  applyToElement(element2) {
+    return { ...element2, refs: this.getPublicAPI() };
+  }
+}
+class ReferencesManager extends BaseReferencesManager {
+  mkManagedRef(refType) {
+    switch (refType) {
+      case 0:
+        return new HTMLElementRefsImpl();
+      case 1:
+        return new HTMLElementCollectionRefImpl();
+      case 2:
+        return new ComponentRefsImpl();
+      case 3:
+        return new ComponentCollectionRefImpl();
+    }
+  }
+  currentContext() {
+    const { currData, coordinate } = currentConstructionContext();
+    return { currData, coordinate };
+  }
+  static for(options, elem, elemCollection, comp, compCollection, childRefManagers) {
+    const refManager = new ReferencesManager(options?.eventWrapper);
+    return [
+      refManager,
+      refManager.mkRefs(elem, elemCollection, comp, compCollection, childRefManagers)
+    ];
+  }
+}
+export {
+  BaseReferencesManager,
+  ComponentCollectionRefImpl,
+  ComponentRefImpl,
+  ComponentRefsImpl,
+  ConstructContext,
+  EVENT_TRAP,
+  GetTrapProxy,
+  ManagedRefType,
+  PrivateRefs,
+  ReferencesManager,
+  booleanAttribute,
+  childComp,
+  conditional,
+  createJayContext,
+  currentConstructionContext,
+  defaultEventWrapper,
+  dynamicAttribute,
+  dynamicElement,
+  dynamicElementNS,
+  dynamicProperty,
+  dynamicText,
+  element,
+  findContext,
+  forEach,
+  isCondition,
+  isForEach,
+  mathMLDynamicElement,
+  mathMLElement,
+  mkUpdateCollection,
+  noopMount,
+  noopUpdate,
+  normalizeMount,
+  normalizeUpdates,
+  restoreContext,
+  saveContext,
+  svgDynamicElement,
+  svgElement,
+  useContext,
+  withContext
+};