element-vir 12.0.0 → 12.0.2

package/dist/declarative-element/declarative-element.d.ts

@@ -28,7 +28,7 @@ export declare abstract class DeclarativeElement<TagNameGeneric extends CustomEl
     abstract readonly instanceState: MaybeAsyncStateToSync<StateInitMaybeAsyncGeneric>;
     abstract readonly asyncStateHandlerMap: AsyncStateHandlerMap<StateInitMaybeAsyncGeneric>;
     abstract readonly instanceInputs: InputsGeneric;
-    abstract assignInputs(inputs: InputsGeneric): void;
+    abstract assignInputs(inputs: {} extends Required<InputsGeneric> ? never : InputsGeneric): void;
     abstract haveInputsBeenSet: boolean;
     abstract markInputsAsHavingBeenSet(): void;
     abstract readonly definition: DeclarativeElementDefinition<TagNameGeneric, InputsGeneric, StateInitMaybeAsyncGeneric, EventsInitGeneric, HostClassKeys, CssVarKeys, RenderOutputGeneric>;

package/dist/declarative-element/define-element-no-inputs.js

@@ -11,7 +11,6 @@ import { IgnoreInputsNotBeenSetBeforeRenderWarningSymbol, defaultDeclarativeElem
 import { assign } from './directives/assign.directive';
 import { hasDeclarativeElementParent } from './has-declarative-element-parent';
 import { assignInputs, markInputsAsHavingBeenSet } from './properties/assign-inputs';
-import { toAsyncStateHandlerMap } from './properties/async-state';
 import { createCssVarNamesMap, createCssVarValuesMap } from './properties/css-vars';
 import { createEventDescriptorMap } from './properties/element-events';
 import { createElementUpdaterProxy } from './properties/element-updater-proxy';
@@ -109,24 +108,14 @@ export function defineElementNoInputs(initInput) {
                 this.haveInputsBeenSet = false;
                 // this is set below in Object.defineProperties
                 this.definition = {};
-                this.asyncStateHandlerMap = toAsyncStateHandlerMap(initInput.stateInit);
+                this.asyncStateHandlerMap = {};
                 this.instanceInputs = createElementUpdaterProxy(this, false);
                 this.instanceState = createElementUpdaterProxy(this, true);
                 const stateInit = initInput.stateInit ||
                     {};
                 getObjectTypedKeys(stateInit).forEach((stateKey) => {
                     property()(this, stateKey);
-                    const asyncStateClassInstance = this.asyncStateHandlerMap[stateKey];
-                    if (asyncStateClassInstance) {
-                        this.instanceState[stateKey] = asyncStateClassInstance.getValue();
-                        asyncStateClassInstance.addSettleListener(() => {
-                            this[stateKey] =
-                                asyncStateClassInstance.getValue();
-                        });
-                    }
-                    else {
-                        this.instanceState[stateKey] = stateInit[stateKey];
-                    }
+                    this.instanceState[stateKey] = stateInit[stateKey];
                 });
                 this.definition = anonymousClass;
             }

package/dist/declarative-element/directives/assign.directive.d.ts

@@ -4,6 +4,6 @@ export type ElementDefinitionWithInputsType<InputsType extends PropertyInitMapBa
     inputsType: InputsType;
 };
 /** Assign an object matching an element's inputs to its inputs. */
-export declare function assign<DeclarativeElementGeneric extends ElementDefinitionWithInputsType>(declarativeElement: DeclarativeElementGeneric, inputsObject: DeclarativeElementGeneric['inputsType']): DirectiveResult;
+export declare function assign<DeclarativeElementGeneric extends ElementDefinitionWithInputsType>(declarativeElement: DeclarativeElementGeneric, inputsObject: {} extends Required<DeclarativeElementGeneric['inputsType']> ? never : DeclarativeElementGeneric['inputsType']): DirectiveResult;
 export declare function assign<DeclarativeElementGeneric extends ElementDefinitionWithInputsType>(inputsObject: Record<string, any>): DirectiveResult;
 export declare function assignInputsObject<DeclarativeElementDefinitionGeneric extends ElementDefinitionWithInputsType>(expectedElementConstructor: DeclarativeElementDefinitionGeneric | undefined, element: Element, assignmentObject: DeclarativeElementDefinitionGeneric['inputsType']): void;

package/dist/declarative-element/properties/assign-inputs.js

@@ -1,7 +1,15 @@
 import { getObjectTypedKeys } from '@augment-vir/common';
 import { property } from 'lit/decorators.js';
 export function assignInputs(element, inputs) {
+    const instanceState = element.instanceState;
     getObjectTypedKeys(inputs).forEach((key) => {
+        if (instanceState && key in instanceState) {
+            throw new Error(`Cannot set input '${key}' on '${element.tagName}'. '${element.tagName}' already has a state property with the same name.`);
+        }
+        /**
+         * No need to check if it's already a property or not, as the property function already
+         * makes that check.
+         */
         property()(element, key);
         if ('instanceInputs' in element) {
             element.instanceInputs[key] = inputs[key];

package/dist/declarative-element/properties/async-state.d.ts

@@ -2,6 +2,7 @@ import { JsonCompatibleValue, UnPromise } from '@augment-vir/common';
 import { PickAndBlockOthers } from '../../augments/type';
 import { PropertyInitMapBase } from './element-properties';
 export type AsyncState<ValueGeneric> = Error | UnPromise<ValueGeneric> | Promise<UnPromise<ValueGeneric>>;
+declare const notSetSymbol: unique symbol;
 export declare function isRenderReady<T>(asyncStateInput: AsyncState<T>): asyncStateInput is UnPromise<T>;
 type AllSetValueProperties<ValueGeneric> = {
     /** Set a new value directly without using any promises. */
@@ -28,20 +29,21 @@ export type AsyncStateInputs<PropertyMapInit extends PropertyInitMapBase> = {
     [Prop in keyof PropertyMapInit]: PropertyMapInit[Prop] extends AsyncStateHandler<infer ValueGeneric> | AsyncStateInit<infer ValueGeneric> ? AsyncStateSetValue<ValueGeneric> : PropertyMapInit[Prop];
 };
 export type AsyncStateHandlerMap<OriginalObjectGeneric extends PropertyInitMapBase> = Partial<Record<keyof OriginalObjectGeneric, AsyncStateHandler<any>>>;
-export declare function toAsyncStateHandlerMap(propertyInitMap?: PropertyInitMapBase | undefined): AsyncStateHandlerMap<PropertyInitMapBase>;
+export type AsyncStateHandlerListener<ValueGeneric> = (handler: AsyncStateHandler<ValueGeneric>) => void;
 export declare class AsyncStateHandler<ValueGeneric> {
     #private;
     readonly asyncMarkerSymbol: symbol;
-    constructor(initialValue: Promise<UnPromise<ValueGeneric>> | UnPromise<ValueGeneric> | undefined);
+    constructor(initialValue: Promise<UnPromise<ValueGeneric>> | UnPromise<ValueGeneric> | typeof notSetSymbol | AsyncStateInit<ValueGeneric>, listener: AsyncStateHandlerListener<ValueGeneric>);
+    resetValue(rawValue: Promise<UnPromise<ValueGeneric>> | UnPromise<ValueGeneric> | typeof notSetSymbol | AsyncStateInit<ValueGeneric>): void;
     setValue(setInputs: AsyncStateSetValue<ValueGeneric>): void;
     getValue(): AsyncState<ValueGeneric>;
-    addSettleListener(callback: () => void): void;
-    removeSettleListener(callback: (value: AsyncState<ValueGeneric>) => void): void;
+    addSettleListener(callback: AsyncStateHandlerListener<ValueGeneric>): void;
+    removeSettleListener(callback: AsyncStateHandlerListener<ValueGeneric>): void;
 }
 export declare class AsyncStateInit<ValueGeneric> {
-    readonly initialValue?: UnPromise<ValueGeneric> | Promise<UnPromise<ValueGeneric>> | undefined;
-    constructor(initialValue?: UnPromise<ValueGeneric> | Promise<UnPromise<ValueGeneric>> | undefined);
+    readonly initialValue: Promise<UnPromise<ValueGeneric>> | UnPromise<ValueGeneric> | typeof notSetSymbol;
+    constructor(initialValue: Promise<UnPromise<ValueGeneric>> | UnPromise<ValueGeneric> | typeof notSetSymbol);
     readonly asyncMarkerSymbol: symbol;
 }
-export declare function asyncState<ValueGeneric>(initialValue?: Promise<UnPromise<ValueGeneric>> | UnPromise<ValueGeneric> | undefined): AsyncStateInit<ValueGeneric>;
+export declare function asyncState<ValueGeneric>(...args: [Promise<UnPromise<ValueGeneric>> | UnPromise<ValueGeneric>] | []): AsyncStateInit<ValueGeneric>;
 export {};

package/dist/declarative-element/properties/async-state.js

@@ -9,9 +9,10 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var _AsyncStateHandler_instances, _AsyncStateHandler_lastTrigger, _AsyncStateHandler_resolutionValue, _AsyncStateHandler_rejectionError, _AsyncStateHandler_listeners, _AsyncStateHandler_lastSetPromise, _AsyncStateHandler_waitingForValuePromise, _AsyncStateHandler_fireListeners, _AsyncStateHandler_setPromise, _AsyncStateHandler_resolveValue;
-import { areJsonEqual, createDeferredPromiseWrapper, ensureError, filterObject, isPromiseLike, mapObjectValues, } from '@augment-vir/common';
+var _AsyncStateHandler_instances, _AsyncStateHandler_lastTrigger, _AsyncStateHandler_resolutionValue, _AsyncStateHandler_rejectionError, _AsyncStateHandler_listeners, _AsyncStateHandler_lastSetPromise, _AsyncStateHandler_waitingForValuePromise, _AsyncStateHandler_fireListeners, _AsyncStateHandler_setPromise, _AsyncStateHandler_resolveValue, _AsyncStateHandler_resetWaitingForValuePromise;
+import { areJsonEqual, createDeferredPromiseWrapper, ensureError, isLengthAtLeast, isPromiseLike, } from '@augment-vir/common';
 const asyncMarkerSymbol = Symbol('element-vir-async-state-marker');
+const notSetSymbol = Symbol('not set');
 export function isRenderReady(asyncStateInput) {
     if (asyncStateInput instanceof Error) {
         return false;
@@ -23,35 +24,30 @@ export function isRenderReady(asyncStateInput) {
         return true;
     }
 }
-export function toAsyncStateHandlerMap(propertyInitMap) {
-    if (!propertyInitMap) {
-        return {};
-    }
-    const asyncStateInit = filterObject(propertyInitMap, (key, value) => {
-        return value instanceof AsyncStateInit;
-    });
-    const asyncStateHandlers = mapObjectValues(asyncStateInit, (key, value) => {
-        return new AsyncStateHandler(value.initialValue);
-    });
-    return asyncStateHandlers;
-}
-const notSetSymbol = Symbol('not set');
 export class AsyncStateHandler {
-    constructor(initialValue) {
+    constructor(initialValue, listener) {
         _AsyncStateHandler_instances.add(this);
         _AsyncStateHandler_lastTrigger.set(this, notSetSymbol);
-        _AsyncStateHandler_resolutionValue.set(this, void 0);
-        _AsyncStateHandler_rejectionError.set(this, void 0);
+        _AsyncStateHandler_resolutionValue.set(this, notSetSymbol);
+        _AsyncStateHandler_rejectionError.set(this, notSetSymbol);
         _AsyncStateHandler_listeners.set(this, []);
         _AsyncStateHandler_lastSetPromise.set(this, void 0);
         _AsyncStateHandler_waitingForValuePromise.set(this, createDeferredPromiseWrapper());
         this.asyncMarkerSymbol = asyncMarkerSymbol;
-        if (initialValue) {
-            if (initialValue instanceof Promise) {
-                this.setValue({ newPromise: initialValue });
+        this.addSettleListener(listener);
+        this.resetValue(initialValue);
+    }
+    resetValue(rawValue) {
+        if (rawValue instanceof AsyncStateInit) {
+            rawValue = rawValue.initialValue;
+        }
+        __classPrivateFieldGet(this, _AsyncStateHandler_instances, "m", _AsyncStateHandler_resetWaitingForValuePromise).call(this);
+        if (rawValue !== notSetSymbol) {
+            if (rawValue instanceof Promise) {
+                this.setValue({ newPromise: rawValue });
             }
             else {
-                this.setValue({ resolvedValue: initialValue });
+                this.setValue({ resolvedValue: rawValue });
             }
         }
     }
@@ -73,26 +69,31 @@ export class AsyncStateHandler {
         else if ('resolvedValue' in setInputs) {
             __classPrivateFieldGet(this, _AsyncStateHandler_instances, "m", _AsyncStateHandler_resolveValue).call(this, setInputs.resolvedValue);
         }
-        else {
-            if (setInputs.forceUpdate) {
-                __classPrivateFieldSet(this, _AsyncStateHandler_lastTrigger, notSetSymbol, "f");
-                __classPrivateFieldSet(this, _AsyncStateHandler_resolutionValue, undefined, "f");
-                if (!__classPrivateFieldGet(this, _AsyncStateHandler_waitingForValuePromise, "f").isSettled()) {
-                    __classPrivateFieldGet(this, _AsyncStateHandler_waitingForValuePromise, "f").reject('Canceled by force update');
-                }
-                __classPrivateFieldSet(this, _AsyncStateHandler_waitingForValuePromise, createDeferredPromiseWrapper(), "f");
-                // force a re-render
-                __classPrivateFieldGet(this, _AsyncStateHandler_instances, "m", _AsyncStateHandler_fireListeners).call(this);
+        else if ('forceUpdate' in setInputs) {
+            __classPrivateFieldSet(this, _AsyncStateHandler_lastTrigger, notSetSymbol, "f");
+            __classPrivateFieldSet(this, _AsyncStateHandler_resolutionValue, notSetSymbol, "f");
+            if (!__classPrivateFieldGet(this, _AsyncStateHandler_waitingForValuePromise, "f").isSettled()) {
+                __classPrivateFieldGet(this, _AsyncStateHandler_waitingForValuePromise, "f").reject('Canceled by force update');
             }
+            __classPrivateFieldGet(this, _AsyncStateHandler_instances, "m", _AsyncStateHandler_resetWaitingForValuePromise).call(this);
+            // force a re-render
+            __classPrivateFieldGet(this, _AsyncStateHandler_instances, "m", _AsyncStateHandler_fireListeners).call(this);
+        }
+        else {
+            this.resetValue(setInputs);
         }
     }
     getValue() {
         if (__classPrivateFieldGet(this, _AsyncStateHandler_waitingForValuePromise, "f").isSettled()) {
-            if (__classPrivateFieldGet(this, _AsyncStateHandler_rejectionError, "f")) {
+            if (__classPrivateFieldGet(this, _AsyncStateHandler_rejectionError, "f") !== notSetSymbol) {
                 return __classPrivateFieldGet(this, _AsyncStateHandler_rejectionError, "f");
             }
-            else
+            else if (__classPrivateFieldGet(this, _AsyncStateHandler_resolutionValue, "f") === notSetSymbol) {
+                throw new Error('Promise says it has settled but resolution value was not set!');
+            }
+            else {
                 return __classPrivateFieldGet(this, _AsyncStateHandler_resolutionValue, "f");
+            }
         }
         else {
             return __classPrivateFieldGet(this, _AsyncStateHandler_waitingForValuePromise, "f").promise;
@@ -107,18 +108,18 @@ export class AsyncStateHandler {
 }
 _AsyncStateHandler_lastTrigger = new WeakMap(), _AsyncStateHandler_resolutionValue = new WeakMap(), _AsyncStateHandler_rejectionError = new WeakMap(), _AsyncStateHandler_listeners = new WeakMap(), _AsyncStateHandler_lastSetPromise = new WeakMap(), _AsyncStateHandler_waitingForValuePromise = new WeakMap(), _AsyncStateHandler_instances = new WeakSet(), _AsyncStateHandler_fireListeners = function _AsyncStateHandler_fireListeners() {
     __classPrivateFieldGet(this, _AsyncStateHandler_listeners, "f").forEach((listener) => {
-        listener();
+        listener(this);
     });
 }, _AsyncStateHandler_setPromise = function _AsyncStateHandler_setPromise(newPromise) {
     if (newPromise === __classPrivateFieldGet(this, _AsyncStateHandler_lastSetPromise, "f")) {
         // abort setting the promise if we already have set this promise
         return;
     }
-    __classPrivateFieldSet(this, _AsyncStateHandler_resolutionValue, undefined, "f");
-    __classPrivateFieldSet(this, _AsyncStateHandler_rejectionError, undefined, "f");
+    __classPrivateFieldSet(this, _AsyncStateHandler_resolutionValue, notSetSymbol, "f");
+    __classPrivateFieldSet(this, _AsyncStateHandler_rejectionError, notSetSymbol, "f");
     __classPrivateFieldSet(this, _AsyncStateHandler_lastSetPromise, newPromise, "f");
     if (__classPrivateFieldGet(this, _AsyncStateHandler_waitingForValuePromise, "f").isSettled()) {
-        __classPrivateFieldSet(this, _AsyncStateHandler_waitingForValuePromise, createDeferredPromiseWrapper(), "f");
+        __classPrivateFieldGet(this, _AsyncStateHandler_instances, "m", _AsyncStateHandler_resetWaitingForValuePromise).call(this);
     }
     newPromise
         .then((value) => {
@@ -143,14 +144,16 @@ _AsyncStateHandler_lastTrigger = new WeakMap(), _AsyncStateHandler_resolutionVal
     });
 }, _AsyncStateHandler_resolveValue = function _AsyncStateHandler_resolveValue(value) {
     if (value !== __classPrivateFieldGet(this, _AsyncStateHandler_resolutionValue, "f")) {
-        __classPrivateFieldSet(this, _AsyncStateHandler_rejectionError, undefined, "f");
+        __classPrivateFieldSet(this, _AsyncStateHandler_rejectionError, notSetSymbol, "f");
         __classPrivateFieldSet(this, _AsyncStateHandler_resolutionValue, value, "f");
         if (__classPrivateFieldGet(this, _AsyncStateHandler_waitingForValuePromise, "f").isSettled()) {
-            __classPrivateFieldSet(this, _AsyncStateHandler_waitingForValuePromise, createDeferredPromiseWrapper(), "f");
+            __classPrivateFieldGet(this, _AsyncStateHandler_instances, "m", _AsyncStateHandler_resetWaitingForValuePromise).call(this);
         }
         __classPrivateFieldGet(this, _AsyncStateHandler_waitingForValuePromise, "f").resolve(value);
         __classPrivateFieldGet(this, _AsyncStateHandler_instances, "m", _AsyncStateHandler_fireListeners).call(this);
     }
+}, _AsyncStateHandler_resetWaitingForValuePromise = function _AsyncStateHandler_resetWaitingForValuePromise() {
+    __classPrivateFieldSet(this, _AsyncStateHandler_waitingForValuePromise, createDeferredPromiseWrapper(), "f");
 };
 export class AsyncStateInit {
     constructor(initialValue) {
@@ -158,6 +161,7 @@ export class AsyncStateInit {
         this.asyncMarkerSymbol = asyncMarkerSymbol;
     }
 }
-export function asyncState(initialValue) {
-    return new AsyncStateInit(initialValue);
+export function asyncState(...args) {
+    const initValue = isLengthAtLeast(args, 1) ? args[0] : notSetSymbol;
+    return new AsyncStateInit(initValue);
 }

package/dist/declarative-element/properties/element-updater-proxy.js

@@ -1,3 +1,4 @@
+import { AsyncStateHandler, AsyncStateInit } from './async-state';
 function assertValidPropertyName(propKey, element, elementTagName) {
     if (typeof propKey !== 'string' && typeof propKey !== 'number' && typeof propKey !== 'symbol') {
         throw new Error(`Property name must be a string, got type '${typeof propKey}' from: '${String(propKey)}' for '${elementTagName.toLowerCase()}'`);
@@ -13,36 +14,52 @@ export function createElementUpdaterProxy(element, verifyExists) {
      * back in here.
      */
     const elementAsProps = element;
-    function valueGetter(target, propertyName) {
+    function valueGetter(target, propertyKey) {
         if (verifyExists) {
-            assertValidPropertyName(propertyName, element, element.tagName);
+            assertValidPropertyName(propertyKey, element, element.tagName);
         }
-        const asyncState = element.asyncStateHandlerMap[propertyName];
+        const asyncState = element.asyncStateHandlerMap[propertyKey];
         if (asyncState) {
             return asyncState.getValue();
         }
         else {
-            return elementAsProps[propertyName];
+            return elementAsProps[propertyKey];
         }
     }
     const propsProxy = new Proxy({}, {
         get: valueGetter,
-        set: (target, propertyName, newValue) => {
+        set: (target, propertyKey, newValue) => {
             if (verifyExists) {
-                assertValidPropertyName(propertyName, element, element.tagName);
+                assertValidPropertyName(propertyKey, element, element.tagName);
             }
             /**
-             * Don't worry about storing the value (no need to have duplicates of teh values) but at
-             * least set the property on target so we can detect it in "ownKeys" and
-             * "getOwnPropertyDescriptor".
+             * We need to at least set the property on target so we can detect it in "ownKeys" and
+             * "getOwnPropertyDescriptor". We don't need duplicates of the values stored in target
+             * but doing so makes console logging more effective it actually works).
              */
-            target[propertyName] = undefined;
-            const asyncState = element.asyncStateHandlerMap[propertyName];
-            if (asyncState) {
-                asyncState.setValue(newValue);
+            target[propertyKey] = newValue;
+            const existingAsyncStateHandler = element.asyncStateHandlerMap[propertyKey];
+            // if we're creating a new async prop
+            if (newValue instanceof AsyncStateInit) {
+                if (existingAsyncStateHandler) {
+                    existingAsyncStateHandler.resetValue(newValue);
+                }
+                else {
+                    const newHandler = new AsyncStateHandler(newValue, (handler) => {
+                        // set the prop directly on the element so that lit catches updates
+                        element[propertyKey] =
+                            handler.getValue();
+                    });
+                    element.asyncStateHandlerMap[propertyKey] = newHandler;
+                }
             }
             else {
-                elementAsProps[propertyName] = newValue;
+                if (existingAsyncStateHandler) {
+                    existingAsyncStateHandler.setValue(newValue);
+                }
+                else {
+                    elementAsProps[propertyKey] = newValue;
+                }
             }
             return true;
         },

package/dist/declarative-element/render-callback.js

@@ -3,13 +3,7 @@ export function createRenderParams(element, eventsMap) {
     function updateState(newStatePartial) {
         getObjectTypedKeys(newStatePartial).forEach((stateKey) => {
             const newValue = newStatePartial[stateKey];
-            const asyncState = element.asyncStateHandlerMap[stateKey];
-            if (asyncState) {
-                asyncState.setValue(newValue);
-            }
-            else {
-                element.instanceState[stateKey] = newValue;
-            }
+            element.instanceState[stateKey] = newValue;
         });
     }
     const renderParams = {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "element-vir",
-    "version": "12.0.0",
+    "version": "12.0.2",
     "keywords": [
         "custom",
         "web",
@@ -39,28 +39,30 @@
         "test:types": "tsc --noEmit"
     },
     "dependencies": {
-        "@augment-vir/browser": "^13.2.4",
-        "@augment-vir/common": "^13.2.4",
+        "@augment-vir/browser": "^13.3.0",
+        "@augment-vir/common": "^13.3.0",
         "lit": "2.7.2"
     },
     "devDependencies": {
-        "@augment-vir/browser-testing": "^13.2.4",
-        "@augment-vir/node-js": "^13.2.4",
+        "@augment-vir/browser-testing": "^13.3.0",
+        "@augment-vir/node-js": "^13.3.0",
         "@istanbuljs/nyc-config-typescript": "^1.0.2",
         "@open-wc/testing": "^3.1.8",
         "@types/mocha": "^10.0.1",
-        "@web/dev-server-esbuild": "^0.3.6",
-        "@web/test-runner": "^0.15.3",
-        "@web/test-runner-commands": "^0.6.6",
-        "@web/test-runner-playwright": "^0.9.0",
-        "@web/test-runner-visual-regression": "^0.7.1",
+        "@web/dev-server-esbuild": "^0.4.1",
+        "@web/test-runner": "^0.16.1",
+        "@web/test-runner-commands": "^0.7.0",
+        "@web/test-runner-playwright": "^0.10.0",
+        "@web/test-runner-visual-regression": "^0.8.0",
         "ansi-colors": "^4.1.3",
         "cspell": "^6.31.1",
+        "esbuild": "^0.17.18",
         "istanbul-smart-text-reporter": "^1.1.1",
         "markdown-code-example-inserter": "^0.3.0",
         "mocha-spec-reporter-with-file-names": "^0.0.3",
+        "npm-check-updates": "^16.10.9",
         "nyc": "^15.1.0",
-        "prettier": "^2.8.7",
+        "prettier": "^2.8.8",
         "prettier-plugin-interpolated-html-tags": "^0.0.3",
         "prettier-plugin-jsdoc": "^0.4.2",
         "prettier-plugin-multiline-arrays": "^1.1.3",
@@ -71,7 +73,8 @@
         "ts-node": "^10.9.1",
         "type-fest": "^3.8.0",
         "typescript": "^5.0.4",
-        "virmator": "^6.4.2",
-        "vite": "^4.2.1"
+        "virmator": "^6.4.3",
+        "vite": "^4.3.1",
+        "vite-tsconfig-paths": "^4.2.0"
     }
 }