@source-crafter/xzor-runtime 0.1.8 → 0.1.10

package/model.js

@@ -0,0 +1,1458 @@
+import {
+  $inSvg,
+  $isFragment,
+  ComponentBase,
+  FINE,
+  SVG,
+  disposeIsland,
+  patchIsland,
+  setFineHooks,
+  setRenderObserver
+} from "./index-qhyvdf2k.js";
+
+// runtime/entity-set.ts
+class EntitySet extends Array {
+  static get [Symbol.species]() {
+    return Array;
+  }
+  static track(type, items) {
+    const set = new EntitySet;
+    if (items)
+      for (const item of items)
+        Array.prototype.push.call(set, new type(item));
+    return set;
+  }
+  #original;
+  #owner;
+  #index = 0;
+  #subs;
+  $own(owner, index) {
+    this.#owner = owner;
+    this.#index = index;
+  }
+  $watch(dep) {
+    const subs = this.#subs ??= [];
+    dep.slot = subs.length;
+    subs.push(dep);
+  }
+  $unwatch(dep) {
+    const subs = this.#subs;
+    if (subs === undefined || subs.length === 0)
+      return;
+    const last = subs.pop();
+    if (last !== dep) {
+      const slot = dep.slot;
+      subs[slot] = last;
+      last.slot = slot;
+    }
+  }
+  [Symbol.iterator]() {
+    Model.$reader?.(this, 0);
+    return super[Symbol.iterator]();
+  }
+  get view() {
+    Model.$reader?.(this, 0);
+    return this.filter((item) => !item.hasState(8 /* Deleted */));
+  }
+  get hasChanges() {
+    Model.$reader?.(this, 0);
+    if (this.#moved())
+      return true;
+    for (let i = 0;i < this.length; i++)
+      if (this[i].hasChanges)
+        return true;
+    return false;
+  }
+  get hasErrors() {
+    Model.$reader?.(this, 0);
+    for (let i = 0;i < this.length; i++)
+      if (this[i].hasErrors)
+        return true;
+    return false;
+  }
+  get changes() {
+    const result = [];
+    for (let i = 0;i < this.length; i++) {
+      const changes = this[i].changes;
+      if (changes)
+        result.push(changes);
+    }
+    return result;
+  }
+  delete(...items) {
+    let touched = false;
+    for (const item of items) {
+      if (item.hasState(4 /* Added */)) {
+        const at = this.indexOf(item);
+        if (at >= 0) {
+          this.#snapshot();
+          super.splice(at, 1);
+          touched = true;
+        }
+      } else if (!item.hasState(1 /* Detached */)) {
+        item.markDeleted();
+        touched = true;
+      }
+    }
+    if (touched)
+      this.#notify();
+    return this;
+  }
+  revertChanges() {
+    const original = this.#original;
+    let touched = original !== undefined;
+    if (original !== undefined) {
+      this.#original = undefined;
+      super.splice(0, this.length, ...original);
+    }
+    for (let i = 0;i < this.length; i++)
+      if (this[i].hasChanges) {
+        this[i].revertChanges();
+        touched = true;
+      }
+    if (touched)
+      this.#notify();
+    return this;
+  }
+  confirmChanges(items) {
+    let touched = this.#original !== undefined;
+    const length = this.length;
+    const limit = items ? Math.min(items.length, length) : length;
+    let w = 0;
+    for (let r = 0;r < length; r++) {
+      const item = this[r];
+      if (r < limit) {
+        const confirmed = items?.[r];
+        if (confirmed === null || item.hasState(8 /* Deleted */))
+          continue;
+        item.confirmChanges(confirmed);
+      }
+      this[w++] = item;
+    }
+    if (w !== length) {
+      this.length = w;
+      touched = true;
+    }
+    this.#original = undefined;
+    if (touched)
+      this.#notify();
+    return this;
+  }
+  push(item) {
+    const count = arguments.length;
+    if (count !== 0) {
+      this.#snapshot();
+      if (count === 1)
+        super.push(item);
+      else
+        super.push(...Array.prototype.slice.call(arguments));
+      this.#notify();
+    }
+    return this.length;
+  }
+  unshift(...items) {
+    if (items.length !== 0) {
+      this.#snapshot();
+      super.unshift(...items);
+      this.#notify();
+    }
+    return this.length;
+  }
+  pop() {
+    if (this.length === 0)
+      return;
+    this.#snapshot();
+    const item = super.pop();
+    this.#notify();
+    return item;
+  }
+  shift() {
+    if (this.length === 0)
+      return;
+    this.#snapshot();
+    const item = super.shift();
+    this.#notify();
+    return item;
+  }
+  splice(start, deleteCount, ...items) {
+    if (items.length === 0) {
+      const length = this.length;
+      const from = start < 0 ? Math.max(length + start, 0) : Math.min(start, length);
+      if (from >= length || deleteCount !== undefined && deleteCount <= 0)
+        return [];
+    }
+    this.#snapshot();
+    const removed = deleteCount === undefined && items.length === 0 ? super.splice(start) : super.splice(start, deleteCount, ...items);
+    this.#notify();
+    return removed;
+  }
+  sort(compare) {
+    this.#snapshot();
+    super.sort(compare);
+    this.#notify();
+    return this;
+  }
+  reverse() {
+    this.#snapshot();
+    super.reverse();
+    this.#notify();
+    return this;
+  }
+  #snapshot() {
+    this.#original ??= this.slice();
+  }
+  #moved() {
+    const original = this.#original;
+    if (original === undefined)
+      return false;
+    if (original.length !== this.length)
+      return true;
+    for (let i = 0;i < original.length; i++)
+      if (original[i] !== this[i])
+        return true;
+    return false;
+  }
+  #notify() {
+    this.#owner?.$touched(this.#index);
+    const subs = this.#subs;
+    if (subs !== undefined)
+      for (let i = 0;i < subs.length; i++)
+        $notify(subs[i], 0);
+  }
+}
+// runtime/fine.ts
+var TEXT = 0;
+var ATTR = 1;
+var REGION = 2;
+var LIST = 3;
+var ISLAND = 4;
+var KIND = 7;
+var QUEUED = 8;
+var MANY = 16;
+var DEAD = 32;
+var LOOSE = 64;
+var ITEM = 128;
+var bitOf = (index) => index === -1 ? 1 << 31 : index < 30 ? 1 << index : 1 << 30;
+var collecting;
+var holder;
+function collect(source, index) {
+  const b = collecting;
+  const bit = bitOf(index);
+  const own = b.model;
+  if (own === source) {
+    b.mask |= bit;
+    return;
+  }
+  if (own === undefined) {
+    b.model = source;
+    b.mask = bit;
+    source.$watch(b);
+    return;
+  }
+  let deps;
+  if ((b.flags & MANY) !== 0)
+    deps = own;
+  else {
+    const first = { model: own, owner: b, mask: b.mask, slot: 0 };
+    own.$unwatch(b);
+    own.$watch(first);
+    b.model = deps = new Map([[own, first]]);
+    b.flags |= MANY;
+  }
+  let dep = deps.get(source);
+  if (dep === undefined) {
+    dep = { model: source, owner: b, mask: 0, slot: 0 };
+    source.$watch(dep);
+    deps.set(source, dep);
+  }
+  dep.mask |= bit;
+}
+
+class Binding {
+  flags;
+  node;
+  read;
+  data;
+  model = undefined;
+  mask = 0;
+  slot = 0;
+  next = undefined;
+  constructor(flags, node, read, data) {
+    this.flags = flags;
+    this.node = node;
+    this.read = read;
+    this.data = data;
+  }
+  get owner() {
+    return this;
+  }
+  get component() {
+    return this;
+  }
+  get renders() {
+    return 0;
+  }
+  get at() {
+    return (this.flags & (QUEUED | DEAD)) !== 0 ? 0 : -1;
+  }
+  set at(value) {
+    if ((this.flags & DEAD) === 0)
+      this.flags = value < 0 ? this.flags & ~QUEUED : this.flags | QUEUED;
+  }
+  #reset() {
+    this.mask = 0;
+    if ((this.flags & MANY) !== 0)
+      for (const dep of this.model.values())
+        dep.mask = 0;
+  }
+  #sweep() {
+    const own = this.model;
+    if (own === undefined)
+      return this.#loose();
+    if ((this.flags & MANY) === 0) {
+      if (this.mask === 0) {
+        own.$unwatch(this);
+        this.model = undefined;
+        this.#loose();
+      }
+      return;
+    }
+    const deps = own;
+    for (const [source, dep] of deps)
+      if (dep.mask === 0) {
+        source.$unwatch(dep);
+        deps.delete(source);
+      }
+    if (deps.size === 0) {
+      this.model = undefined;
+      this.flags &= ~MANY;
+      this.#loose();
+    }
+  }
+  #loose() {
+    if ((this.flags & (LOOSE | DEAD)) !== 0 || holder === undefined)
+      return;
+    this.flags |= LOOSE;
+    holder.ctx.loose.push(this);
+  }
+  #run(parent) {
+    const prev = collecting;
+    const reader = Model.$reader;
+    collecting = this;
+    Model.$reader = collect;
+    this.#reset();
+    try {
+      return (this.flags & ITEM) !== 0 ? this.read(this.data.item, parent) : this.read(parent);
+    } finally {
+      collecting = prev;
+      Model.$reader = reader;
+      this.#sweep();
+    }
+  }
+  stateHasChanged() {
+    const flags = this.flags;
+    if ((flags & DEAD) !== 0)
+      return;
+    switch (flags & KIND) {
+      case TEXT: {
+        const value = this.#run();
+        if ($isFragment(value))
+          return this.#becomeIsland();
+        const text = textOf(value);
+        const node = this.node;
+        if (node.data !== text)
+          node.data = text;
+        return;
+      }
+      case ATTR:
+        return setAttr(this.node, (flags & ITEM) !== 0 ? this.read.$n : this.data, this.#run());
+      case REGION: {
+        const region = this.data;
+        disposeAll(region);
+        const end = this.node;
+        const parent = end.parentNode;
+        while (region.start.nextSibling !== end)
+          parent.removeChild(region.start.nextSibling);
+        const frag = document.createDocumentFragment();
+        within(region, () => this.#run(frag));
+        parent.insertBefore(frag, end);
+        return;
+      }
+      case LIST:
+        return reconcile(this, this.#run());
+      case ISLAND:
+        this.#run();
+        return;
+    }
+  }
+  #becomeIsland() {
+    const read = this.read;
+    const h = this.data;
+    const value = (this.flags & ITEM) !== 0 ? () => read(h.item) : read;
+    const text = this.node;
+    const end = text.parentNode.insertBefore(document.createComment(""), text.nextSibling);
+    text.parentNode.removeChild(text);
+    this.node = end;
+    this.flags = this.flags & ~(KIND | ITEM) | ISLAND;
+    island(this, h.ctx, (b) => {
+      const v = value();
+      if ($isFragment(v))
+        v(b);
+      else
+        b.addContent(v);
+    });
+    this.stateHasChanged();
+  }
+  dispose() {
+    if ((this.flags & DEAD) !== 0)
+      return;
+    const kind = this.flags & KIND;
+    if (kind === REGION)
+      disposeAll(this.data);
+    else if (kind === LIST)
+      for (const row of this.data.order)
+        disposeAll(row);
+    else if (kind === ISLAND) {
+      disposeIsland(this.data.tree);
+      this.data.tree = [];
+    }
+    this.#reset();
+    this.#sweep();
+    this.flags = DEAD;
+  }
+}
+function island(b, ctx, build) {
+  const state = { ctx, tree: [], build };
+  b.data = state;
+  b.read = () => {
+    state.tree = patchIsland(ctx.owner, ctx.app, ctx.scope, b.node, state.tree, build);
+  };
+}
+function refreshLoose(ctx) {
+  const loose = ctx.loose;
+  for (let i = 0;i < loose.length; ) {
+    const b = loose[i];
+    if ((b.flags & DEAD) !== 0 || b.model !== undefined) {
+      b.flags &= ~LOOSE;
+      loose[i] = loose[loose.length - 1];
+      loose.pop();
+      continue;
+    }
+    b.stateHasChanged();
+    i++;
+  }
+}
+function afterHandler(ctx, result) {
+  $flush();
+  refreshLoose(ctx);
+  if (result instanceof Promise)
+    result.then(() => refreshLoose(ctx));
+}
+function within(h, run) {
+  const prev = holder;
+  holder = h;
+  try {
+    run();
+  } finally {
+    holder = prev;
+  }
+}
+function track(b) {
+  const h = holder;
+  b.next = h.bindings;
+  h.bindings = b;
+  b.stateHasChanged();
+}
+function disposeAll(h) {
+  for (let b = h.bindings;b !== undefined; b = b.next)
+    b.dispose();
+  h.bindings = undefined;
+}
+function refreshAll(h) {
+  for (let b = h.bindings;b !== undefined; b = b.next) {
+    b.stateHasChanged();
+    if ((b.flags & KIND) === LIST)
+      for (const row of b.data.order)
+        refreshAll(row);
+  }
+}
+var textOf = (value) => value === null || value === undefined || value === false ? "" : String(value);
+function setAttr(el, name, value) {
+  if (value === null || value === undefined || value === false) {
+    if (el.hasAttribute(name))
+      el.removeAttribute(name);
+    if (name === "checked" && "checked" in el)
+      el.checked = false;
+    return;
+  }
+  const text = value === true ? "" : String(value);
+  if (el.getAttribute(name) !== text)
+    el.setAttribute(name, text);
+  if (name === "value" && "value" in el && el.value !== text)
+    el.value = text;
+  else if (name === "checked" && "checked" in el)
+    el.checked = true;
+}
+function removeRange(head, tail) {
+  const parent = head.parentNode;
+  for (let node = head;; ) {
+    const next = node.nextSibling;
+    parent.removeChild(node);
+    if (node === tail)
+      return;
+    node = next;
+  }
+}
+function reconcile(list, items) {
+  const state = list.data;
+  const end = list.node;
+  const parent = end.parentNode;
+  const next = Array.isArray(items) ? items : [...items];
+  const keep = new Set(next);
+  for (const [item, row] of state.rows)
+    if (!keep.has(item)) {
+      disposeAll(row);
+      removeRange(row.head, row.tail);
+      state.rows.delete(item);
+    }
+  let cursor = end;
+  for (const row of state.order)
+    if (row.head.parentNode === parent) {
+      cursor = row.head;
+      break;
+    }
+  const order = [];
+  for (const item of next) {
+    let row = state.rows.get(item);
+    if (row === undefined) {
+      const frag = document.createDocumentFragment();
+      const made = { bindings: undefined, ctx: state.ctx, head: frag, tail: frag, item, reads: state.reads };
+      within(made, () => state.build(frag, item));
+      if (frag.firstChild === null)
+        frag.appendChild(document.createComment(""));
+      made.head = frag.firstChild;
+      made.tail = frag.lastChild;
+      parent.insertBefore(frag, cursor);
+      state.rows.set(item, row = made);
+    } else if (row.head !== cursor) {
+      for (let node = row.head;; ) {
+        const after = node.nextSibling;
+        parent.insertBefore(node, cursor);
+        if (node === row.tail)
+          break;
+        node = after;
+      }
+    } else
+      cursor = row.tail.nextSibling;
+    order.push(row);
+  }
+  state.order = order;
+}
+function make(spec, svg = false) {
+  if (spec === null)
+    return document.createComment("");
+  if (typeof spec === "string")
+    return document.createTextNode(spec);
+  const tag = spec[0];
+  const el = svg || tag === "svg" ? document.createElementNS(SVG, tag) : document.createElement(tag);
+  const attrs = spec[1];
+  if (attrs !== 0)
+    for (let i = 0;i < attrs.length; i += 2)
+      el.setAttribute(attrs[i], attrs[i + 1]);
+  const inner = $inSvg(el);
+  for (let i = 2;i < spec.length; i++)
+    el.appendChild(make(spec[i], inner));
+  return el;
+}
+var DELEGATED = new Set(["beforeinput", "click", "dblclick", "contextmenu", "focusin", "focusout", "input", "keydown", "keyup", "mousedown", "mousemove", "mouseout", "mouseover", "mouseup", "pointerdown", "pointermove", "pointerout", "pointerover", "pointerup", "touchend", "touchmove", "touchstart"]);
+var keys = new Map;
+var HOLDER = Symbol("xzor.fine.holder");
+function keyOf(type) {
+  let key = keys.get(type);
+  if (key === undefined) {
+    keys.set(type, key = Symbol(type));
+    document.addEventListener(type, dispatch);
+    document.addEventListener(type, dispatchAtTarget, true);
+  }
+  return key;
+}
+function fire(node, e) {
+  const handler = node[keys.get(e.type)];
+  if (handler === undefined)
+    return false;
+  const h = node[HOLDER];
+  Object.defineProperty(e, "currentTarget", { configurable: true, value: node });
+  afterHandler(h.ctx, h.reads !== undefined ? handler(h.item)(e) : handler(e));
+  return e.cancelBubble;
+}
+function dispatch(e) {
+  for (let node = e.target;node !== null && !fire(node, e); node = node.parentNode)
+    ;
+}
+function dispatchAtTarget(e) {
+  if (!e.bubbles && e.target !== null)
+    fire(e.target, e);
+}
+function on(el, event, handler, h) {
+  if (DELEGATED.has(event)) {
+    const target = el;
+    target[keyOf(event)] = handler;
+    target[HOLDER] = h;
+  } else
+    el.addEventListener(event, (e) => afterHandler(h.ctx, handler(e)));
+}
+function region(start, end, build, item, flags) {
+  const region2 = { bindings: undefined, ctx: holder.ctx, start, item };
+  track(new Binding(REGION | flags, end, build, region2));
+}
+function list(end, items, reads, build) {
+  const state = { build, ctx: holder.ctx, rows: new Map, order: [], reads };
+  track(new Binding(LIST, end, items, state));
+}
+var anchor = (parent) => parent.appendChild(document.createComment(""));
+var fine = {
+  template(specs) {
+    let node;
+    let used = false;
+    const build = () => {
+      const first = specs[0];
+      if (specs.length === 1 && Array.isArray(first))
+        return make(first);
+      const frag = document.createDocumentFragment();
+      for (const spec of specs)
+        frag.appendChild(make(spec));
+      return frag;
+    };
+    return () => {
+      if (node !== undefined)
+        return node.cloneNode(true);
+      if (!used) {
+        used = true;
+        return build();
+      }
+      node = build();
+      return node.cloneNode(true);
+    };
+  },
+  el(parent, tag) {
+    return parent.appendChild($inSvg(parent) ? document.createElementNS(SVG, tag) : document.createElement(tag));
+  },
+  on(el, event, handler) {
+    const h = holder;
+    on(el, event, h.reads !== undefined && DELEGATED.has(event) ? () => handler : handler, h);
+  },
+  onItem(el, event, i) {
+    const row = holder;
+    const read = row.reads[i];
+    if (DELEGATED.has(event))
+      on(el, event, read, row);
+    else
+      el.addEventListener(event, (e) => afterHandler(row.ctx, read(row.item)(e)));
+  },
+  t(parent, text) {
+    parent.appendChild(document.createTextNode(text));
+  },
+  text(parent, read) {
+    fine.textAt(parent.appendChild(document.createTextNode("")), read);
+  },
+  textAt(node, read) {
+    track(new Binding(TEXT, node, read, holder));
+  },
+  textItem(node, i) {
+    const row = holder;
+    track(new Binding(TEXT | ITEM, node, row.reads[i], row));
+  },
+  attr(el, name, read) {
+    track(new Binding(ATTR, el, read, name));
+  },
+  attrItem(el, name, i) {
+    const row = holder;
+    const read = row.reads[i];
+    read.$n = name;
+    track(new Binding(ATTR | ITEM, el, read, row));
+  },
+  region(parent, build) {
+    region(anchor(parent), anchor(parent), build, undefined, 0);
+  },
+  regionAt(end, build) {
+    region(end.previousSibling, end, build, undefined, 0);
+  },
+  regionItem(end, i) {
+    const row = holder;
+    region(end.previousSibling, end, row.reads[i], row.item, ITEM);
+  },
+  list(parent, items, build) {
+    list(anchor(parent), items, undefined, build);
+  },
+  listAt(end, items, reads, build) {
+    list(end, items, reads, build);
+  },
+  island(parent, build) {
+    fine.islandAt(anchor(parent), build);
+  },
+  islandAt(end, build) {
+    const b = new Binding(ISLAND, end, noop, undefined);
+    island(b, holder.ctx, build);
+    track(b);
+  }
+};
+var noop = () => {};
+var FIELDS = Symbol("xzor.fine.fields");
+
+class FineComponent extends ComponentBase {
+  #subs;
+  static get $reader() {
+    return Model.$reader;
+  }
+  static same(a, b) {
+    return Model.same(a, b);
+  }
+  static $define(cls, names) {
+    const counts = cls;
+    const at = counts[FIELDS] ?? 0;
+    counts[FIELDS] = at + names.length;
+    return at;
+  }
+  $watch(dep) {
+    const subs = this.#subs ??= [];
+    dep.slot = subs.length;
+    subs.push(dep);
+  }
+  $unwatch(dep) {
+    const subs = this.#subs;
+    if (subs === undefined || subs.length === 0)
+      return;
+    const last = subs.pop();
+    if (last !== dep) {
+      subs[dep.slot] = last;
+      last.slot = dep.slot;
+    }
+  }
+  $changed(index, _previous) {
+    const subs = this.#subs;
+    if (subs !== undefined)
+      for (let i = 0;i < subs.length; i++)
+        $notify(subs[i], index);
+  }
+}
+FineComponent.prototype[FINE] = true;
+var CTX = Symbol("xzor.fine.ctx");
+setFineHooks({
+  create(build, owner, app, scope) {
+    const frag = document.createDocumentFragment();
+    const start = frag.appendChild(document.createComment(""));
+    const ctx = { owner, app, scope, loose: [] };
+    owner[CTX] = ctx;
+    const root = { bindings: undefined, ctx, start, end: start };
+    const reader = Model.$reader;
+    Model.$reader = undefined;
+    try {
+      within(root, () => build(frag));
+    } finally {
+      Model.$reader = reader;
+    }
+    root.end = frag.appendChild(document.createComment(""));
+    return root;
+  },
+  refresh: (root) => refreshAll(root),
+  dispose: (root) => disposeAll(root),
+  handled(owner, result) {
+    const ctx = owner[CTX];
+    if (ctx !== undefined)
+      afterHandler(ctx, result);
+  }
+});
+
+// runtime/model.ts
+var State;
+((State2) => {
+  State2[State2["Detached"] = 1] = "Detached";
+  State2[State2["Unchanged"] = 2] = "Unchanged";
+  State2[State2["Added"] = 4] = "Added";
+  State2[State2["Deleted"] = 8] = "Deleted";
+  State2[State2["Modified"] = 16] = "Modified";
+})(State ||= {});
+var Changed = 4 /* Added */ | 8 /* Deleted */ | 16 /* Modified */;
+
+class ModelChangeEvent extends Event {
+  property;
+  value;
+  previous;
+  index;
+  constructor(property, value, previous, index) {
+    super("change");
+    this.property = property;
+    this.value = value;
+    this.previous = previous;
+    this.index = index;
+  }
+}
+var stateIndex = -1;
+var StateKey = Symbol("xzor.state");
+var meta = Symbol("xzor.model.meta");
+var empty = { names: [], tracked: new Set, persisted: [], ignored: new Set, validators: [], serialized: [] };
+var pendingPersist;
+var pendingIgnored;
+var pendingValidators;
+var silent = 0;
+function metaOf(model) {
+  return model.constructor[meta] ?? empty;
+}
+function serialized(of) {
+  return of.serialized ??= of.names.concat(of.persisted).filter((name) => !of.ignored.has(name));
+}
+function captureOf(options) {
+  return typeof options === "object" && options !== null ? options.capture === true : options === true;
+}
+
+class Model extends EventTarget {
+  static $reader;
+  #state;
+  #originals;
+  #watched;
+  #subs;
+  constructor(data) {
+    super();
+    const state = data?.$$;
+    this.#state = state ?? (data ? 2 /* Unchanged */ : 1 /* Detached */);
+  }
+  static $define(cls, names) {
+    const base = cls[meta];
+    const all = base ? base.names.concat(names) : names;
+    const own = {
+      names: all,
+      tracked: new Set(all),
+      persisted: base ? base.persisted.slice() : [],
+      ignored: new Set(base?.ignored),
+      validators: base ? base.validators.map(([name, list2]) => [name, list2.slice()]) : []
+    };
+    if (pendingValidators) {
+      for (const [name, list2] of pendingValidators) {
+        const known = own.validators.find((entry) => entry[0] === name);
+        if (known)
+          known[1].push(...list2);
+        else
+          own.validators.push([name, list2]);
+      }
+      pendingValidators = undefined;
+    }
+    if (pendingPersist) {
+      for (const name of pendingPersist)
+        own.persisted.push(name);
+      pendingPersist = undefined;
+    }
+    if (pendingIgnored) {
+      for (const name of pendingIgnored)
+        own.ignored.add(name);
+      pendingIgnored = undefined;
+    }
+    Object.defineProperty(cls, meta, { value: own });
+    return base ? base.names.length : 0;
+  }
+  static same(a, b) {
+    if (Object.is(a, b))
+      return true;
+    if (a === null || b === null || typeof a !== "object" || typeof b !== "object")
+      return false;
+    if (a instanceof Date || b instanceof Date)
+      return a instanceof Date && b instanceof Date && a.getTime() === b.getTime();
+    if (a instanceof Model || b instanceof Model || "$own" in a || "$own" in b)
+      return false;
+    if (Array.isArray(a) || Array.isArray(b)) {
+      if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length)
+        return false;
+      return a.every((value, i) => Model.same(value, b[i]));
+    }
+    const left = a;
+    const right = b;
+    const names = Object.keys(left);
+    if (names.length !== Object.keys(right).length)
+      return false;
+    return names.every((name) => Model.same(left[name], right[name]));
+  }
+  get [StateKey]() {
+    Model.$reader?.(this, stateIndex);
+    return this.#state;
+  }
+  set [StateKey](value) {
+    if (value === this.#state)
+      return;
+    this.#state = value;
+    const subs = this.#subs;
+    if (subs !== undefined)
+      for (let i = 0;i < subs.length; i++)
+        changed(subs[i], stateIndex);
+    if (!this.#listens("state"))
+      return;
+    const depth = silent;
+    silent = 0;
+    try {
+      this.dispatchEvent(new Event("state"));
+    } finally {
+      silent = depth;
+    }
+  }
+  hasState(flags) {
+    Model.$reader?.(this, stateIndex);
+    return (this.#state & flags) !== 0;
+  }
+  get hasChanges() {
+    Model.$reader?.(this, stateIndex);
+    if ((this.#state & Changed) !== 0)
+      return true;
+    for (const name of metaOf(this).names)
+      if (valueHasChanges(this[name]))
+        return true;
+    return false;
+  }
+  get hasErrors() {
+    Model.$reader?.(this, stateIndex);
+    if ((this.#state & (1 /* Detached */ | 8 /* Deleted */)) !== 0)
+      return false;
+    const own = metaOf(this);
+    const values = this;
+    for (let i = 0;i < own.validators.length; i++) {
+      const [name, list2] = own.validators[i];
+      for (const validate of list2)
+        if (typeof validate(values[name], this) === "string")
+          return true;
+    }
+    for (const name of own.names)
+      if (valueHasErrors(values[name]))
+        return true;
+    return false;
+  }
+  get errors() {
+    const result = Object.create(null);
+    Model.$reader?.(this, stateIndex);
+    if ((this.#state & (1 /* Detached */ | 8 /* Deleted */)) !== 0)
+      return result;
+    if (this.#originals === undefined && (this.#state & (4 /* Added */ | 16 /* Modified */)) === 0)
+      return result;
+    const values = this;
+    const validators = metaOf(this).validators;
+    for (let i = 0;i < validators.length; i++) {
+      const [name, list2] = validators[i];
+      const messages = result[name] = [];
+      for (const validate of list2) {
+        const message = validate(values[name], this);
+        if (typeof message === "string")
+          messages.push(message);
+      }
+    }
+    return result;
+  }
+  get hasValidChanges() {
+    return this.hasChanges && !this.hasErrors;
+  }
+  get changes() {
+    if (!this.hasChanges)
+      return null;
+    const values = this;
+    const result = { $$: this.#state };
+    for (const name of serialized(metaOf(this))) {
+      const value = values[name];
+      if (isSerializable(value))
+        result[name] = changesOf(value);
+    }
+    return result;
+  }
+  toJSON() {
+    const values = this;
+    const result = { $$: this.#state };
+    for (const name of serialized(metaOf(this)))
+      result[name] = values[name];
+    return result;
+  }
+  revertChanges() {
+    const own = metaOf(this);
+    const originals = this.#originals;
+    const values = this;
+    if (originals) {
+      this.#originals = undefined;
+      silent++;
+      try {
+        for (const name in originals) {
+          const previous = values[name];
+          const value = originals[name];
+          values[name] = value;
+          this.#emit(name, value, previous);
+        }
+      } finally {
+        silent--;
+      }
+    }
+    for (const name of own.names)
+      revertValue(values[name]);
+    if ((this.#state & 4 /* Added */) !== 0)
+      this[StateKey] = 1 /* Detached */;
+    else if ((this.#state & (8 /* Deleted */ | 16 /* Modified */)) !== 0)
+      this[StateKey] = 2 /* Unchanged */;
+    return this;
+  }
+  confirmChanges(values) {
+    const own = metaOf(this);
+    const data = values;
+    const target = this;
+    this.#originals = undefined;
+    silent++;
+    try {
+      for (const name of own.names) {
+        const current = target[name];
+        const given = data !== undefined && Object.hasOwn(data, name);
+        if (current !== null && typeof current === "object" && typeof current.confirmChanges === "function") {
+          current.confirmChanges(given ? data[name] : undefined);
+        } else if (given) {
+          const value = data[name];
+          if (Model.same(current, value))
+            continue;
+          target[name] = value;
+          this.#emit(name, value, current);
+        }
+      }
+    } finally {
+      silent--;
+    }
+    if ((this.#state & (4 /* Added */ | 16 /* Modified */)) !== 0)
+      this[StateKey] = 2 /* Unchanged */;
+    return this;
+  }
+  markAdded() {
+    this[StateKey] = 4 /* Added */;
+    return this;
+  }
+  markModified() {
+    if ((this.#state & 4 /* Added */) === 0)
+      this[StateKey] = 16 /* Modified */;
+    return this;
+  }
+  markUnchanged() {
+    this[StateKey] = 2 /* Unchanged */;
+    return this;
+  }
+  markDeleted() {
+    if ((this.#state & 1 /* Detached */) === 0)
+      this[StateKey] = 8 /* Deleted */;
+    return this;
+  }
+  assign(data) {
+    const names = metaOf(this).names;
+    const target = this;
+    if (data) {
+      const tracked = metaOf(this).tracked;
+      const source = data;
+      if (source["$$"] != null)
+        this.#state = source["$$"];
+      silent++;
+      try {
+        for (const name in source)
+          if (tracked.has(name))
+            try {
+              target[name] = source[name];
+            } catch (error) {
+              if (!(error instanceof TypeError))
+                throw error;
+            }
+      } finally {
+        silent--;
+      }
+    }
+    const reader = Model.$reader;
+    Model.$reader = undefined;
+    try {
+      for (let i = 0;i < names.length; i++)
+        try {
+          attach(target[names[i]], this, i);
+        } catch (error) {
+          if (!(error instanceof TypeError))
+            throw error;
+        }
+    } finally {
+      Model.$reader = reader;
+    }
+    return this;
+  }
+  addEventListener(type, callback, options) {
+    if (!callback || type !== "change" && type !== "state") {
+      super.addEventListener(type, callback, options);
+      return;
+    }
+    const settings = typeof options === "object" && options !== null ? options : undefined;
+    if (settings?.signal?.aborted)
+      return;
+    const capture = captureOf(options);
+    const watched = this.#watched ??= [];
+    for (const known of watched)
+      if (known.type === type && known.callback === callback && known.capture === capture)
+        return;
+    const watch = { type, callback, capture };
+    watched.push(watch);
+    if (settings?.once)
+      watch.wrapped = (event) => {
+        this.#forget(watch);
+        if (typeof callback === "function")
+          callback.call(this, event);
+        else
+          callback.handleEvent(event);
+      };
+    super.addEventListener(type, watch.wrapped ?? callback, options);
+    settings?.signal?.addEventListener("abort", () => this.#forget(watch), { once: true });
+  }
+  removeEventListener(type, callback, options) {
+    let target = callback;
+    const watched = this.#watched;
+    if (callback && watched) {
+      const capture = captureOf(options);
+      for (let i = 0;i < watched.length; i++) {
+        const watch = watched[i];
+        if (watch.type === type && watch.callback === callback && watch.capture === capture) {
+          watched.splice(i, 1);
+          target = watch.wrapped ?? callback;
+          break;
+        }
+      }
+    }
+    super.removeEventListener(type, target, options);
+  }
+  $changed(index, previous) {
+    if (silent !== 0)
+      return;
+    const name = metaOf(this).names[index];
+    const originals = this.#originals ??= Object.create(null);
+    if (!(name in originals))
+      originals[name] = previous;
+    if ((this.#state & 1 /* Detached */) !== 0)
+      this[StateKey] = 4 /* Added */;
+    else if ((this.#state & 2 /* Unchanged */) !== 0)
+      this[StateKey] = 16 /* Modified */;
+    const reader = Model.$reader;
+    Model.$reader = undefined;
+    const value = this[name];
+    Model.$reader = reader;
+    attach(value, this, index);
+    this.#emit(name, value, previous, index);
+  }
+  $touched(index) {
+    const name = metaOf(this).names[index];
+    const reader = Model.$reader;
+    Model.$reader = undefined;
+    const value = this[name];
+    Model.$reader = reader;
+    this.#emit(name, value, value, index);
+  }
+  #emit(name, value, previous, index) {
+    if (!this.#hasListener("change")) {
+      const subs = this.#subs;
+      if (subs === undefined || subs.length === 0)
+        return;
+      const at = index ?? metaOf(this).names.indexOf(name);
+      for (let i = 0;i < subs.length; i++)
+        changed(subs[i], at);
+      return;
+    }
+    const depth = silent;
+    silent = 0;
+    try {
+      this.dispatchEvent(new ModelChangeEvent(name, value, previous, index));
+    } finally {
+      silent = depth;
+    }
+  }
+  $watch(dep) {
+    const subs = this.#subs ??= [];
+    dep.slot = subs.length;
+    subs.push(dep);
+  }
+  $unwatch(dep) {
+    const subs = this.#subs;
+    if (subs === undefined || subs.length === 0)
+      return;
+    const last = subs.pop();
+    if (last !== dep) {
+      subs[dep.slot] = last;
+      last.slot = dep.slot;
+    }
+  }
+  dispatchEvent(event) {
+    const subs = this.#subs;
+    if (subs !== undefined && subs.length !== 0 && event.type === "change") {
+      const e = event;
+      const index = e.index ?? metaOf(this).names.indexOf(e.property);
+      if (index >= 0)
+        for (let i = 0;i < subs.length; i++)
+          changed(subs[i], index);
+    }
+    return super.dispatchEvent(event);
+  }
+  #listens(type) {
+    if (type === "change" && this.#subs !== undefined && this.#subs.length !== 0)
+      return true;
+    return this.#hasListener(type);
+  }
+  #hasListener(type) {
+    const watched = this.#watched;
+    if (watched === undefined)
+      return false;
+    for (let i = 0;i < watched.length; i++)
+      if (watched[i].type === type)
+        return true;
+    return false;
+  }
+  #forget(watch) {
+    const watched = this.#watched;
+    if (!watched)
+      return;
+    const i = watched.indexOf(watch);
+    if (i >= 0)
+      watched.splice(i, 1);
+  }
+}
+function Persist(_getter, context) {
+  (pendingPersist ??= []).push(context.name);
+}
+function Validate(...validators) {
+  return (_member, context) => {
+    (pendingValidators ??= []).push([context.name, validators]);
+  };
+}
+function Ignore(_member, context) {
+  (pendingIgnored ??= []).push(context.name);
+}
+function Untracked(_value, _context) {}
+function isLike(a, b) {
+  return Model.same(a, b);
+}
+function attach(value, owner, index) {
+  if (value !== null && typeof value === "object") {
+    const set = value;
+    if (typeof set.$own === "function")
+      set.$own(owner, index);
+  }
+}
+function valueHasChanges(value) {
+  if (value === null || typeof value !== "object" || value instanceof Date)
+    return false;
+  const changes = value.hasChanges;
+  if (typeof changes === "boolean")
+    return changes;
+  if (Array.isArray(value))
+    return value.some(valueHasChanges);
+  return Object.values(value).some(valueHasChanges);
+}
+function valueHasErrors(value) {
+  if (value === null || typeof value !== "object" || value instanceof Date)
+    return false;
+  const errors = value.hasErrors;
+  if (typeof errors === "boolean")
+    return errors;
+  if (Array.isArray(value))
+    return value.some(valueHasErrors);
+  return Object.values(value).some(valueHasErrors);
+}
+function isSerializable(value) {
+  if (value === null)
+    return true;
+  const type = typeof value;
+  if (type === "string" || type === "number" || type === "boolean")
+    return true;
+  return value instanceof Date || valueHasChanges(value);
+}
+function changesOf(value) {
+  if (value === null || typeof value !== "object" || value instanceof Date)
+    return value;
+  const owner = value;
+  if (typeof owner.hasChanges === "boolean")
+    return owner.changes;
+  if (Array.isArray(value))
+    return value.filter(valueHasChanges).map(changesOf);
+  const result = {};
+  for (const [name, nested] of Object.entries(value))
+    if (isSerializable(nested))
+      result[name] = changesOf(nested);
+  return result;
+}
+function revertValue(value) {
+  if (value === null || typeof value !== "object")
+    return;
+  const owner = value;
+  if (typeof owner.revertChanges === "function") {
+    if (owner.hasChanges)
+      owner.revertChanges();
+  } else if (Array.isArray(value))
+    value.forEach(revertValue);
+}
+var required = (value) => value !== undefined && value !== null && (typeof value !== "string" || value.trim() !== "") ? true : "Field is required";
+var emailTest = /^((([a-z]|\d|[!#$%&'*+\-\/=?^_`{|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+(\.([a-z]|\d|[!#$%&'*+\-\/=?^_`{|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+)*)|((\x22)(((([\x20\x09])*(\x0d\x0a))?([\x20\x09])+)?(([\x01-\x08\x0b\x0c\x0e-\x1f\x7f]|\x21|[\x23-\x5b]|[\x5d-\x7e]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(\\([\x01-\x09\x0b\x0c\x0d-\x7f]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))))*((([\x20\x09])*(\x0d\x0a))?([\x20\x09])+)?(\x22)))@((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.?$/i;
+var email = (value) => (value ?? "").length <= 254 && emailTest.test(value ?? "") ? true : "Field should be a valid e-mail";
+var phoneTest = /^(\+\s?)?((?<!\+.*)\(\+?\d+([\s\-.]?\d+)?\)|\d)(?:\d|[\s\-.]\d|[\s\-.]?\(\d+(?:[\s\-.]?\d+)?\))*(\s?(x|ext\.?)\s?\d+)?$/i;
+function isValidPhone(value) {
+  return value == null || phoneTest.test(value);
+}
+var phone = (value) => isValidPhone(value ?? null) ? true : "Field should be a valid phone";
+var maxLength = (length) => (value) => `${value}`.length <= length ? true : `Field length is limited to ${length}`;
+var minLength = (length) => (value) => `${value}`.length >= length ? true : `Field min length is ${length} characters`;
+var requiredIdValue = (value) => required(value) === true && value > 0 ? true : "Field is required";
+var nonZero = (value) => value > 0 ? true : "Value must be greater than 0";
+var minValue = (min, inclusive = true) => (value) => (inclusive ? value >= min : value > min) ? true : `Field must be greater than ${inclusive ? "or equal to " : ""}${min}`;
+var maxValue = (max, inclusive = true) => (value) => (inclusive ? value <= max : value < max) ? true : `Field must be less than ${inclusive ? "or equal to " : ""}${max}`;
+var reads = Symbol("xzor.model.reads");
+var readsOf = (c) => c[reads];
+var stack = [];
+var queued = [];
+var current;
+var currentReads;
+var bitOf2 = (index) => index === stateIndex ? 1 << 31 : index < 30 ? 1 << index : 1 << 30;
+function subscribe(own, model) {
+  const dep = { model, owner: own, mask: 0, epoch: own.epoch, slot: 0 };
+  model.$watch(dep);
+  own.size++;
+  own.seen++;
+  return dep;
+}
+function read(model, index) {
+  let own = currentReads;
+  if (own === undefined) {
+    own = currentReads = {
+      component: current,
+      first: undefined,
+      more: undefined,
+      epoch: 1,
+      renders: 1,
+      at: -1,
+      size: 0,
+      seen: 0
+    };
+    current[reads] = own;
+  }
+  let dep = own.first;
+  if (dep === undefined)
+    dep = own.first = subscribe(own, model);
+  else if (dep.model !== model) {
+    dep = own.more?.get(model);
+    if (dep === undefined) {
+      dep = subscribe(own, model);
+      (own.more ??= new Map).set(model, dep);
+    }
+  }
+  if (dep.epoch !== own.epoch) {
+    dep.epoch = own.epoch;
+    dep.mask = 0;
+    own.seen++;
+  }
+  dep.mask |= bitOf2(index);
+}
+function changed(dep, index) {
+  if ((dep.mask & bitOf2(index)) === 0)
+    return;
+  const own = dep.owner;
+  if (own.at < 0) {
+    queued.push(own);
+    if (queued.length === 1)
+      queueMicrotask(flush);
+  }
+  own.at = own.renders;
+}
+function flush() {
+  for (const own of queued.splice(0)) {
+    const at = own.at;
+    own.at = -1;
+    if (own.renders === at)
+      own.component.stateHasChanged();
+  }
+}
+var $notify = changed;
+var $flush = flush;
+function sweep(own) {
+  const more = own.more;
+  if (more !== undefined) {
+    for (const dep of more.values())
+      if (dep.epoch !== own.epoch) {
+        dep.model.$unwatch(dep);
+        more.delete(dep.model);
+        own.size--;
+      }
+    if (more.size === 0)
+      own.more = undefined;
+  }
+  const first = own.first;
+  if (first !== undefined && first.epoch !== own.epoch) {
+    first.model.$unwatch(first);
+    own.first = undefined;
+    own.size--;
+    const rest = own.more;
+    if (rest !== undefined) {
+      for (const [model, dep] of rest) {
+        own.first = dep;
+        rest.delete(model);
+        break;
+      }
+      if (rest.size === 0)
+        own.more = undefined;
+    }
+  }
+}
+setRenderObserver({
+  begin(component) {
+    stack.push(component);
+    current = component;
+    const own = currentReads = readsOf(component);
+    if (own !== undefined) {
+      own.epoch++;
+      own.renders++;
+      own.seen = 0;
+    }
+    Model.$reader = read;
+  },
+  end(_component) {
+    const own = currentReads;
+    if (own !== undefined && own.seen !== own.size)
+      sweep(own);
+    stack.pop();
+    current = stack[stack.length - 1];
+    currentReads = current === undefined ? undefined : readsOf(current);
+    if (current === undefined)
+      Model.$reader = undefined;
+  },
+  dispose(component) {
+    const own = readsOf(component);
+    if (own === undefined)
+      return;
+    if (own.first !== undefined)
+      own.first.model.$unwatch(own.first);
+    if (own.more !== undefined)
+      for (const dep of own.more.values())
+        dep.model.$unwatch(dep);
+    own.first = own.more = undefined;
+    own.size = 0;
+    own.renders++;
+  }
+});
+export {
+  $flush,
+  $notify,
+  EntitySet,
+  FineComponent,
+  Ignore,
+  Model,
+  ModelChangeEvent,
+  Persist,
+  State,
+  StateKey,
+  Untracked,
+  Validate,
+  email,
+  fine,
+  isLike,
+  isValidPhone,
+  maxLength,
+  maxValue,
+  minLength,
+  minValue,
+  nonZero,
+  phone,
+  required,
+  requiredIdValue
+};
+
+//# debugId=61B5F3F4B8CDA71064756E2164756E21
+//# sourceMappingURL=model.js.map