aberdeen 1.17.1 → 2.0.0

package/dist/tests/helpers.js

@@ -1,29 +1,8 @@
 // @bun
-var __defProp = Object.defineProperty;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
+// tests/environment.ts
+import { createA } from "aberdeen";
 
-// tests/fakedom.ts
-var exports_fakedom = {};
-__export(exports_fakedom, {
-  setMediaQuery: () => setMediaQuery,
-  resetCounts: () => resetCounts,
-  resetBrowserState: () => resetBrowserState,
-  passTime: () => passTime,
-  getCounts: () => getCounts,
-  clearBody: () => clearBody
-});
+// src/server-dom.ts
 var newCount = 0;
 var changeCount = 0;
 var resetCounts = function() {
@@ -32,13 +11,11 @@ var resetCounts = function() {
 var getCounts = function() {
   return { new: newCount, changed: changeCount };
 };
-var clearBody = function() {
-  document2.body.childNodes.length = 0;
-};
 
 class Node {
   parentNode = null;
   childNodes = [];
+  ownerDocument = null;
   get nextSibling() {
     return this.getSibling(1);
   }
@@ -56,13 +33,15 @@ class Node {
   }
 }
 
-class Element2 extends Node {
+class Element extends Node {
   tagName;
   namespaceURI;
   _style = {};
   attrs = {};
   events = {};
   _classList;
+  _scrollTop;
+  _scrollLeft;
   constructor(tag, namespaceURI) {
     super();
     this.tagName = tag;
@@ -141,7 +120,7 @@ class Element2 extends Node {
     });
   }
   get parentElement() {
-    if (this.parentNode instanceof Element2)
+    if (this.parentNode instanceof Element)
       return this.parentNode;
     return;
   }
@@ -176,7 +155,7 @@ class Element2 extends Node {
   }
   _querySelectorAllRecursive(selector, results) {
     for (const child of this.childNodes) {
-      if (child instanceof Element2) {
+      if (child instanceof Element) {
         if (child.tagName === selector) {
           results.push(child);
         }
@@ -187,7 +166,7 @@ class Element2 extends Node {
   set innerHTML(html) {
     this.childNodes = [];
     if (html) {
-      let n = new Element2("fake-emulated-html");
+      let n = new Element("fake-emulated-html");
       n.textContent = html;
       this.appendChild(n);
     }
@@ -227,8 +206,6 @@ class Element2 extends Node {
   set scrollLeft(value) {
     this._scrollLeft = value;
   }
-  _scrollTop;
-  _scrollLeft;
   toString() {
     let arr = [];
     for (let [symbol, items, toKebab] of [["=", this.attrs, false], ["->", this, false], [":", this.style, true]]) {
@@ -284,7 +261,7 @@ class Element2 extends Node {
     if (this.attrs.id === id)
       return this;
     for (let child of this.childNodes) {
-      if (child instanceof Element2) {
+      if (child instanceof Element) {
         let el = child.getElementById(id);
         if (el)
           return el;
@@ -293,225 +270,7 @@ class Element2 extends Node {
     return;
   }
 }
-var document2 = {
-  createElement: (tag) => new Element2(tag, "http://www.w3.org/1999/xhtml"),
-  createElementNS: (namespaceURI, tag) => new Element2(tag, namespaceURI),
-  createTextNode: (text) => new TextNode(text),
-  head: new Element2("head", "http://www.w3.org/1999/xhtml"),
-  body: new Element2("body", "http://www.w3.org/1999/xhtml")
-};
-
-class FakeLocation {
-  _href = "http://localhost/";
-  get href() {
-    return this._href;
-  }
-  set href(value) {
-    if (value.startsWith("/")) {
-      const currentUrl = new URL(this._href);
-      this._href = `${currentUrl.protocol}//${currentUrl.host}${value}`;
-    } else {
-      this._href = value;
-    }
-  }
-  get host() {
-    const url = new URL(this._href);
-    return url.host;
-  }
-  get pathname() {
-    const url = new URL(this._href);
-    return url.pathname;
-  }
-  set pathname(value) {
-    const url = new URL(this._href);
-    url.pathname = value;
-    this._href = url.href;
-  }
-  get search() {
-    const url = new URL(this._href);
-    return url.search;
-  }
-  set search(value) {
-    const url = new URL(this._href);
-    url.search = value;
-    this._href = url.href;
-  }
-  get hash() {
-    const url = new URL(this._href);
-    return url.hash;
-  }
-  set hash(value) {
-    const url = new URL(this._href);
-    url.hash = value;
-    this._href = url.href;
-  }
-}
-
-class FakeHistory {
-  _state = null;
-  _entries = [];
-  _index = 0;
-  constructor() {
-    this._entries = [{ url: location.href, state: null }];
-  }
-  get state() {
-    return this._state;
-  }
-  pushState(state, title, url) {
-    this._entries = this._entries.slice(0, this._index + 1);
-    this._entries.push({ url, state });
-    this._index = this._entries.length - 1;
-    this._state = state;
-    location.href = url;
-  }
-  replaceState(state, title, url) {
-    this._entries[this._index] = { url, state };
-    this._state = state;
-    location.href = url;
-  }
-  go(delta) {
-    const newIndex = this._index + delta;
-    if (newIndex >= 0 && newIndex < this._entries.length) {
-      this._index = newIndex;
-      const entry = this._entries[this._index];
-      this._state = entry.state;
-      location.href = entry.url;
-      setTimeout(() => {
-        const event = {
-          type: "popstate",
-          state: this._state,
-          target: window,
-          preventDefault: () => {},
-          stopPropagation: () => {}
-        };
-        window.dispatchEvent(event);
-      }, 0);
-    }
-  }
-  back() {
-    this.go(-1);
-  }
-  forward() {
-    this.go(1);
-  }
-  _reset() {
-    this._state = null;
-    this._entries = [{ url: location.href, state: null }];
-    this._index = 0;
-  }
-  _getLength() {
-    return this._entries.length;
-  }
-}
-
-class FakeWindow {
-  _listeners = {};
-  addEventListener(type, listener) {
-    if (!this._listeners[type]) {
-      this._listeners[type] = new Set;
-    }
-    this._listeners[type].add(listener);
-  }
-  removeEventListener(type, listener) {
-    if (this._listeners[type]) {
-      this._listeners[type].delete(listener);
-    }
-  }
-  dispatchEvent(event) {
-    const listeners = this._listeners[event.type];
-    if (listeners) {
-      for (const listener of listeners) {
-        listener.call(this, event);
-      }
-    }
-  }
-  matchMedia(query) {
-    if (!mediaQueries.has(query)) {
-      mediaQueries.set(query, new MediaQueryList(query));
-    }
-    return mediaQueries.get(query);
-  }
-  _reset() {
-    this._listeners = {};
-  }
-}
-var location = new FakeLocation;
-var history = new FakeHistory;
-var window = new FakeWindow;
-var resetBrowserState = function() {
-  location.href = "http://localhost/";
-  history._reset();
-};
-var timeouts = [];
-var currentTime = 0;
-var deferredErrors = [];
-var realSetTimeout = global.setTimeout;
-var realClearTimeout = global.clearTimeout;
-function fireItem(item) {
-  const idx = timeouts.indexOf(item);
-  if (idx < 0)
-    return;
-  timeouts.splice(idx, 1);
-  if (item.time > currentTime)
-    currentTime = item.time;
-  item.func();
-}
-var setTimeout = function(func, time) {
-  const item = { func, time: time + currentTime, realId: undefined };
-  item.realId = realSetTimeout(() => {
-    try {
-      fireItem(item);
-    } catch (e) {
-      deferredErrors.push(e);
-    }
-  }, time);
-  timeouts.push(item);
-};
-var queueMicrotask = function(func) {
-  const item = { func, time: 0, realId: undefined };
-  item.realId = realSetTimeout(() => {
-    try {
-      fireItem(item);
-    } catch (e) {
-      deferredErrors.push(e);
-    }
-  }, 0);
-  timeouts.push(item);
-};
-var passTime = async function(ms = 0) {
-  let targetTime = currentTime + ms;
-  while (true) {
-    await new Promise((resolve) => realSetTimeout(resolve, 0));
-    if (deferredErrors.length) {
-      const err = deferredErrors.shift();
-      throw err;
-    }
-    if (!timeouts.length) {
-      let settled = false;
-      for (let r = 0;r < 5 && !settled; r++) {
-        await new Promise((resolve) => realSetTimeout(resolve, 0));
-        settled = timeouts.length > 0;
-      }
-      if (!settled)
-        break;
-    }
-    let smallestIdx = 0;
-    for (let idx = 1;idx < timeouts.length; idx++) {
-      if (timeouts[idx].time < timeouts[smallestIdx].time)
-        smallestIdx = idx;
-    }
-    let item = timeouts[smallestIdx];
-    if (item.time > targetTime)
-      break;
-    timeouts.splice(smallestIdx, 1);
-    realClearTimeout(item.realId);
-    if (item.time > currentTime)
-      currentTime = item.time;
-    await item.func();
-  }
-  currentTime = targetTime;
-};
-var IGNORE_OUTPUT = new Set("tagName-> attrs-> events-> childNodes-> parentNode-> class= namespaceURI->".split(" "));
+var IGNORE_OUTPUT = new Set("tagName-> attrs-> events-> childNodes-> parentNode-> class= namespaceURI-> ownerDocument->".split(" "));
 
 class TextNode extends Node {
   textContent;
@@ -527,52 +286,271 @@ class TextNode extends Node {
     this.parentNode?.removeChild(this);
   }
 }
-function getComputedStyle(el) {
-  return el._style;
+var XHTML_NS = "http://www.w3.org/1999/xhtml";
+function createDocument() {
+  const doc = {
+    createElement: (tag) => own(new Element(tag, XHTML_NS)),
+    createElementNS: (namespaceURI, tag) => own(new Element(tag, namespaceURI)),
+    createTextNode: (text) => own(new TextNode(text)),
+    head: new Element("head", XHTML_NS),
+    body: new Element("body", XHTML_NS),
+    defaultView: null
+  };
+  function own(node) {
+    node.ownerDocument = doc;
+    return node;
+  }
+  own(doc.head);
+  own(doc.body);
+  return doc;
 }
+var VOID_ELEMENTS = new Set("area base br col embed hr img input link meta param source track wbr".split(" "));
+var RAW_TEXT_ELEMENTS = new Set(["script", "style"]);
 
-class MediaQueryList {
-  matches;
-  media;
-  listeners = new Set;
-  constructor(query) {
-    this.media = query;
-    const preset = mediaQueryPresets.get(query);
-    this.matches = preset !== undefined ? preset : query.includes("dark") ? false : true;
-  }
-  addEventListener(type, listener) {
-    if (type === "change") {
-      this.listeners.add(listener);
+// tests/environment.ts
+var realSetTimeout = globalThis.setTimeout;
+var realClearTimeout = globalThis.clearTimeout;
+function createEnvironment() {
+  let timeouts = [];
+  let currentTime = 0;
+  let deferredErrors = [];
+  function fireItem(item) {
+    const idx = timeouts.indexOf(item);
+    if (idx < 0)
+      return;
+    timeouts.splice(idx, 1);
+    if (item.time > currentTime)
+      currentTime = item.time;
+    item.func();
+  }
+  const setTimeout = function(func, time = 0) {
+    const item = { func, time: time + currentTime, realId: undefined };
+    item.realId = realSetTimeout(() => {
+      try {
+        fireItem(item);
+      } catch (e) {
+        deferredErrors.push(e);
+      }
+    }, time);
+    timeouts.push(item);
+  };
+  const queueMicrotask = function(func) {
+    const item = { func, time: 0, realId: undefined };
+    item.realId = realSetTimeout(() => {
+      try {
+        fireItem(item);
+      } catch (e) {
+        deferredErrors.push(e);
+      }
+    }, 0);
+    timeouts.push(item);
+  };
+  const passTime = async function(ms = 0) {
+    let targetTime = currentTime + ms;
+    while (true) {
+      await new Promise((resolve) => realSetTimeout(resolve, 0));
+      if (deferredErrors.length) {
+        const err = deferredErrors.shift();
+        throw err;
+      }
+      if (!timeouts.length) {
+        let settled = false;
+        for (let r = 0;r < 5 && !settled; r++) {
+          await new Promise((resolve) => realSetTimeout(resolve, 0));
+          settled = timeouts.length > 0;
+        }
+        if (!settled)
+          break;
+      }
+      let smallestIdx = 0;
+      for (let idx = 1;idx < timeouts.length; idx++) {
+        if (timeouts[idx].time < timeouts[smallestIdx].time)
+          smallestIdx = idx;
+      }
+      let item = timeouts[smallestIdx];
+      if (item.time > targetTime)
+        break;
+      timeouts.splice(smallestIdx, 1);
+      realClearTimeout(item.realId);
+      if (item.time > currentTime)
+        currentTime = item.time;
+      await item.func();
+    }
+    currentTime = targetTime;
+  };
+  const mediaQueries = new Map;
+  const mediaQueryPresets = new Map;
+
+  class MediaQueryList {
+    matches;
+    media;
+    listeners = new Set;
+    constructor(query) {
+      this.media = query;
+      const preset = mediaQueryPresets.get(query);
+      this.matches = preset !== undefined ? preset : query.includes("dark") ? false : true;
+    }
+    addEventListener(type, listener) {
+      if (type === "change")
+        this.listeners.add(listener);
+    }
+    removeEventListener(type, listener) {
+      if (type === "change")
+        this.listeners.delete(listener);
+    }
+    _trigger(matches) {
+      this.matches = matches;
+      for (const listener of this.listeners)
+        listener({ matches, media: this.media });
     }
   }
-  removeEventListener(type, listener) {
-    if (type === "change") {
-      this.listeners.delete(listener);
+  function setMediaQuery(query, matches) {
+    mediaQueryPresets.set(query, matches);
+    if (mediaQueries.has(query))
+      mediaQueries.get(query)._trigger(matches);
+  }
+
+  class FakeLocation {
+    _href = "http://localhost/";
+    get href() {
+      return this._href;
+    }
+    set href(value) {
+      if (value.startsWith("/")) {
+        const currentUrl = new URL(this._href);
+        this._href = `${currentUrl.protocol}//${currentUrl.host}${value}`;
+      } else
+        this._href = value;
+    }
+    get host() {
+      return new URL(this._href).host;
+    }
+    get pathname() {
+      return new URL(this._href).pathname;
+    }
+    set pathname(value) {
+      const u = new URL(this._href);
+      u.pathname = value;
+      this._href = u.href;
+    }
+    get search() {
+      return new URL(this._href).search;
+    }
+    set search(value) {
+      const u = new URL(this._href);
+      u.search = value;
+      this._href = u.href;
+    }
+    get hash() {
+      return new URL(this._href).hash;
+    }
+    set hash(value) {
+      const u = new URL(this._href);
+      u.hash = value;
+      this._href = u.href;
     }
   }
-  _trigger(matches) {
-    this.matches = matches;
-    const event = { matches, media: this.media };
-    for (const listener of this.listeners) {
-      listener(event);
+
+  class FakeHistory {
+    _state = null;
+    _entries = [{ url: "http://localhost/", state: null }];
+    _index = 0;
+    get state() {
+      return this._state;
+    }
+    pushState(state, _title, url) {
+      this._entries = this._entries.slice(0, this._index + 1);
+      this._entries.push({ url, state });
+      this._index = this._entries.length - 1;
+      this._state = state;
+      location.href = url;
+    }
+    replaceState(state, _title, url) {
+      this._entries[this._index] = { url, state };
+      this._state = state;
+      location.href = url;
+    }
+    go(delta) {
+      const newIndex = this._index + delta;
+      if (newIndex >= 0 && newIndex < this._entries.length) {
+        this._index = newIndex;
+        const entry = this._entries[this._index];
+        this._state = entry.state;
+        location.href = entry.url;
+        setTimeout(() => window.dispatchEvent({
+          type: "popstate",
+          state: this._state,
+          target: window,
+          preventDefault: () => {},
+          stopPropagation: () => {}
+        }), 0);
+      }
+    }
+    back() {
+      this.go(-1);
+    }
+    forward() {
+      this.go(1);
     }
   }
-}
-var mediaQueries = new Map;
-var mediaQueryPresets = new Map;
-function setMediaQuery(query, matches) {
-  mediaQueryPresets.set(query, matches);
-  if (mediaQueries.has(query)) {
-    mediaQueries.get(query)._trigger(matches);
+
+  class FakeWindow {
+    _listeners = {};
+    addEventListener(type, listener) {
+      (this._listeners[type] ||= new Set).add(listener);
+    }
+    removeEventListener(type, listener) {
+      this._listeners[type]?.delete(listener);
+    }
+    dispatchEvent(event) {
+      this._listeners[event.type]?.forEach((l) => l.call(this, event));
+    }
+    matchMedia(query) {
+      if (!mediaQueries.has(query))
+        mediaQueries.set(query, new MediaQueryList(query));
+      return mediaQueries.get(query);
+    }
   }
+  const location = new FakeLocation;
+  const history = new FakeHistory;
+  const window = new FakeWindow;
+  const getComputedStyle = (el) => el._style;
+  const document = createDocument();
+  Object.assign(window, { document, Node, Element, TextNode, location, history, setTimeout, queueMicrotask, getComputedStyle });
+  document.defaultView = window;
+  const A = createA(window);
+  resetCounts();
+  return { A, window, document, location, history, setTimeout, passTime, setMediaQuery, getCounts, resetCounts };
 }
-var globals = { Node, Element: Element2, TextNode, document: document2, window, setTimeout, queueMicrotask, getComputedStyle, location, history, URLSearchParams };
-Object.assign(global, globals);
-Object.assign(window, globals);
 
 // tests/helpers.ts
-import { expect } from "bun:test";
-import A from "aberdeen";
+import { expect, beforeEach } from "bun:test";
+var env;
+var A;
+var window;
+var document;
+var location;
+var history;
+var setTimeout;
+var passTime;
+function newEnvironment() {
+  env = createEnvironment();
+  A = env.A;
+  window = env.window;
+  document = env.document;
+  location = env.location;
+  history = env.history;
+  setTimeout = env.setTimeout;
+  passTime = env.passTime;
+}
+newEnvironment();
+beforeEach(newEnvironment);
+function setMediaQuery(query, matches) {
+  env.setMediaQuery(query, matches);
+}
+function getCounts2() {
+  return env.getCounts();
+}
 function toDisplay(value) {
   if (value instanceof Map) {
     let results = [];
@@ -640,40 +618,33 @@ async function assertThrow(a, b) {
   }
   throw new AssertError(`exception expected`, undefined, `something containing "${a}"`, true);
 }
-var passTime2 = passTime;
 function assertDomUpdates(expected) {
-  const counts = getCounts();
+  const counts = env.getCounts();
   if (expected.new != null)
     expect(counts.new).toEqual(expected.new);
   if (expected.changed != null)
     expect(counts.changed).toEqual(expected.changed);
 }
-async function reset() {
-  A.copy(A.cssVars, {});
-  A.unmountAll();
-  try {
-    await passTime(2001);
-    assertBody(``);
-  } finally {
-    clearBody();
-  }
-  resetCounts();
-  A.setErrorHandler();
-}
 export {
-  reset,
-  passTime2 as passTime,
+  window,
+  setTimeout,
+  setMediaQuery,
+  passTime,
+  location,
+  history,
   getCss,
+  getCounts2 as getCounts,
   getBody,
-  exports_fakedom as fakedom,
+  document,
   assertThrow,
   assertDomUpdates,
   assertCss,
   assertContains,
   assertBody,
   assert,
-  AssertError
+  AssertError,
+  A
 };
 
-//# debugId=CFA9235CDB3924EF64756E2164756E21
+//# debugId=E9E14C2775DDDF9564756E2164756E21
 //# sourceMappingURL=helpers.js.map