tungsten 0.2.9 → 0.2.11

package/dist/testing/index.js

@@ -0,0 +1,157 @@
+function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
+function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
+function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
+function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
+import { Instance } from "../Instance/Instance.js";
+import { initStores } from "../Servers/initStores.js";
+import { ensureTestEnvLoaded } from "./ensureTestEnvLoaded.js";
+export { ensureTestEnvLoaded, testEnvVariableName } from "./ensureTestEnvLoaded.js";
+import { createTungstenRootComponent, deleteTungstenRoot } from "../update/integrateUpdateVdom.js";
+import { UpdateScheduler } from "../update/UpdateScheduler.js";
+export function testStore(registration, initialize) {
+  return {
+    registration,
+    initialize
+  };
+}
+var _instance = /*#__PURE__*/new WeakMap();
+var _scheduler = /*#__PURE__*/new WeakMap();
+var _root = /*#__PURE__*/new WeakMap();
+var _ownsContainer = /*#__PURE__*/new WeakMap();
+var _unmounted = /*#__PURE__*/new WeakMap();
+class TestAppImplementation {
+  constructor(document, container, component, instance, scheduler, root, ownsContainer) {
+    _defineProperty(this, "document", void 0);
+    _defineProperty(this, "container", void 0);
+    _defineProperty(this, "component", void 0);
+    _classPrivateFieldInitSpec(this, _instance, void 0);
+    _classPrivateFieldInitSpec(this, _scheduler, void 0);
+    _classPrivateFieldInitSpec(this, _root, void 0);
+    _classPrivateFieldInitSpec(this, _ownsContainer, void 0);
+    _classPrivateFieldInitSpec(this, _unmounted, false);
+    _defineProperty(this, "resolved", async () => {
+      await _classPrivateFieldGet(_scheduler, this).resolved();
+    });
+    _defineProperty(this, "setProps", async props => {
+      if (_classPrivateFieldGet(_unmounted, this)) throw new Error('Cannot set props on an unmounted Tungsten TestApp.');
+      this.component.props = props;
+      _classPrivateFieldGet(_instance, this).queueUpdate(this.component);
+      await this.resolved();
+    });
+    _defineProperty(this, "unmount", async () => {
+      if (_classPrivateFieldGet(_unmounted, this)) return;
+      _classPrivateFieldSet(_unmounted, this, true);
+      _classPrivateFieldGet(_scheduler, this).cancelPending();
+      let cleanupError;
+      try {
+        deleteTungstenRoot(_classPrivateFieldGet(_root, this));
+        _classPrivateFieldGet(_instance, this).disposeRegisteredComponents();
+        await _classPrivateFieldGet(_scheduler, this).resolved();
+      } catch (error) {
+        cleanupError = error;
+        try {
+          _classPrivateFieldGet(_instance, this).disposeRegisteredComponents();
+        } catch {
+          // Preserve the first cleanup failure.
+        }
+      } finally {
+        _classPrivateFieldGet(_scheduler, this).dispose();
+        if (_classPrivateFieldGet(_ownsContainer, this)) this.container.remove();else while (this.container.firstChild !== null) this.container.removeChild(this.container.firstChild);
+      }
+      if (cleanupError !== undefined) throw cleanupError;
+    });
+    this.document = document;
+    this.container = container;
+    this.component = component;
+    _classPrivateFieldSet(_instance, this, instance);
+    _classPrivateFieldSet(_scheduler, this, scheduler);
+    _classPrivateFieldSet(_root, this, root);
+    _classPrivateFieldSet(_ownsContainer, this, ownsContainer);
+  }
+}
+export async function createTestApp(RootComponent, ...args) {
+  await ensureTestEnvLoaded();
+  const options = args[0];
+  const suppliedDocument = options?.document ?? globalThis.document;
+  if (suppliedDocument === undefined) {
+    // eslint-disable-line @typescript-eslint/no-unnecessary-condition
+    throw new Error('createTestApp() requires options.document when no global document is available.');
+  }
+  const document = suppliedDocument;
+  const ownsContainer = options?.container === undefined;
+  const container = options?.container ?? document.createElement('div');
+  if (container.ownerDocument !== document) {
+    throw new Error('The TestApp container must belong to options.document.');
+  }
+  if (container.childNodes.length > 0) {
+    throw new Error('The TestApp container must be empty before mounting.');
+  }
+  if (ownsContainer) {
+    if (document.body === null) {
+      // eslint-disable-line @typescript-eslint/no-unnecessary-condition
+      throw new Error('The supplied document must have a body element.');
+    }
+    document.body.appendChild(container);
+  }
+  const location = options?.location ?? '/';
+  const globalData = options?.globalData ?? {};
+  const matchedRouteInfo = {
+    key: null,
+    params: options?.routeParams ?? {},
+    content: null,
+    ...(options !== undefined && 'routeData' in options ? {
+      data: options.routeData
+    } : {})
+  };
+  const scheduler = new UpdateScheduler();
+  const runtimeContext = {
+    document,
+    window: document.defaultView,
+    scheduler,
+    navigation: false
+  };
+  const {
+    internalStore,
+    stores,
+    storeSubscriptions
+  } = initStores(location, null, globalData, matchedRouteInfo);
+  const instanceConfig = {
+    prod: false,
+    useRootComponent: true,
+    clientSideNav: false,
+    siteBasePath: '/',
+    staticSite: false
+  };
+  const emptyRoutes = {};
+  const instance = new Instance(location, instanceConfig, null, emptyRoutes, emptyRoutes, internalStore, stores, storeSubscriptions, globalData, matchedRouteInfo, runtimeContext);
+  try {
+    for (const override of options?.stores ?? []) {
+      const store = override.registration.getStore(instance.stores);
+      await override.initialize(store);
+    }
+    const props = options?.props ?? {};
+    const root = await createTungstenRootComponent(RootComponent, props, options?.routeParams, options?.routeData, instance, container);
+    const testApp = new TestAppImplementation(document, container, root.component, instance, scheduler, root, ownsContainer);
+    try {
+      await testApp.resolved();
+      return testApp;
+    } catch (error) {
+      await testApp.unmount();
+      throw error;
+    }
+  } catch (error) {
+    try {
+      instance.disposeRegisteredComponents();
+    } catch {
+      // Preserve the mount failure.
+    }
+    scheduler.dispose();
+    while (container.firstChild !== null) container.removeChild(container.firstChild);
+    if (ownsContainer) container.remove();
+    throw error;
+  }
+}

package/dist/update/integrateUpdateVdom.js

@@ -1188,7 +1188,6 @@ async function updateClassComponent({
   //throwError('','')
   const updateResult = await element.__update();
   domPointer.increment(updateResult.nodesLength); // bump the dom pointer index forward by the number of nodes within that element's content
-  element.__didUpdate();
   return {
     ...newNode,
     element,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tungsten",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "description": "",
   "type": "module",
   "bin": {

package/readme.md

@@ -1,5 +1,5 @@
-# Tungsten Frontend Framework
-
+# Tungsten Frontend Framework
+
 [Docs](https://robertsandiford.co.uk/tungsten)
 
 ## Component testing