element-vir 9.0.1 → 9.1.1

package/dist/augments/type.d.ts

@@ -6,4 +6,5 @@ export type NonEmptyString<T> = T extends '' ? never : T;
  * testing packages.
  */
 export declare function ensureInstanceOf<T>(value: unknown, constructor: new (...args: any) => T, message?: string): asserts value is T;
+export type PickAndBlockOthers<OriginalObject, PickKeys extends keyof OriginalObject> = Pick<OriginalObject, PickKeys> & Partial<Record<Exclude<keyof OriginalObject, PickKeys>, never>>;
 //# sourceMappingURL=type.d.ts.map

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

@@ -1,35 +1,26 @@
 import { UnPromise } from '@augment-vir/common';
 import { JsonValue, Promisable } from 'type-fest';
+import { PickAndBlockOthers } from '../../augments/type';
 import { PropertyInitMapBase } from './element-properties';
 export type AsyncState<ValueGeneric> = Error | Promisable<UnPromise<ValueGeneric>>;
-export type AsyncStateSetValue<ValueGeneric> = {
+type AllSetValueProperties<ValueGeneric> = {
+    /** Set a new value directly without using any promises. */
+    resolvedValue: UnPromise<ValueGeneric>;
     createPromise: () => Promise<UnPromise<ValueGeneric>>;
     /**
      * When trigger changes (according to deep equality checking through JSON stringify), the
      * createPromise callback will be called and the element's state will be updated again.
      * Otherwise, the createPromise callback will only be called the first time.
      *
-     * Set this to undefined to disabled automatic updating. Meaning, createPromise will only
-     * be called the first time.
+     * Set this to undefined to disabled automatic updating. Meaning, createPromise will only be
+     * called the first time.
      */
     trigger: JsonValue | Readonly<JsonValue> | undefined;
-    newPromise?: never;
-    forceUpdate?: never;
-} | {
-    createPromise?: never;
-    trigger?: never;
-    forceUpdate?: never;
     newPromise: Promise<UnPromise<ValueGeneric>>;
-} | {
-    createPromise?: never;
-    trigger?: never;
-    newPromise?: never;
-    /**
-     * Clear the current value and trigger createPromise to get called again on the next
-     * render.
-     */
+    /** Clear the current value and trigger createPromise to get called again on the next render. */
     forceUpdate: true;
 };
+export type AsyncStateSetValue<ValueGeneric> = PickAndBlockOthers<AllSetValueProperties<ValueGeneric>, 'createPromise' | 'trigger'> | PickAndBlockOthers<AllSetValueProperties<ValueGeneric>, 'newPromise'> | PickAndBlockOthers<AllSetValueProperties<ValueGeneric>, 'forceUpdate'> | PickAndBlockOthers<AllSetValueProperties<ValueGeneric>, 'resolvedValue'>;
 export type MaybeAsyncStateToSync<PropertyMapInit extends PropertyInitMapBase> = {
     [Prop in keyof PropertyMapInit]: PropertyMapInit[Prop] extends AsyncStateHandler<infer ValueGeneric> | AsyncStateInit<infer ValueGeneric> ? AsyncState<ValueGeneric> : PropertyMapInit[Prop];
 };
@@ -51,4 +42,5 @@ export declare class AsyncStateInit<ValueGeneric> {
     constructor(initialValue?: Promise<UnPromise<ValueGeneric>> | undefined);
 }
 export declare function asyncState<ValueGeneric>(initialValue?: Promise<UnPromise<ValueGeneric>> | undefined): AsyncStateInit<ValueGeneric>;
+export {};
 //# sourceMappingURL=async-state.d.ts.map

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

@@ -9,7 +9,7 @@ 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;
+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, mapObjectValues, } from '@augment-vir/common';
 export function toAsyncStateHandlerMap(propertyInitMap) {
     if (!propertyInitMap) {
@@ -52,6 +52,9 @@ export class AsyncStateHandler {
             // force a re-render
             __classPrivateFieldGet(this, _AsyncStateHandler_instances, "m", _AsyncStateHandler_fireListeners).call(this);
         }
+        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");
@@ -93,6 +96,8 @@ _AsyncStateHandler_lastTrigger = new WeakMap(), _AsyncStateHandler_resolutionVal
         // 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_lastSetPromise, newPromise, "f");
     if (__classPrivateFieldGet(this, _AsyncStateHandler_waitingForValuePromise, "f").isSettled()) {
         __classPrivateFieldSet(this, _AsyncStateHandler_waitingForValuePromise, createDeferredPromiseWrapper(), "f");
@@ -101,10 +106,7 @@ _AsyncStateHandler_lastTrigger = new WeakMap(), _AsyncStateHandler_resolutionVal
         .then((value) => {
         // make sure we're still actually waiting for this promise
         if (__classPrivateFieldGet(this, _AsyncStateHandler_lastSetPromise, "f") === newPromise) {
-            __classPrivateFieldSet(this, _AsyncStateHandler_rejectionError, undefined, "f");
-            __classPrivateFieldSet(this, _AsyncStateHandler_resolutionValue, value, "f");
-            __classPrivateFieldGet(this, _AsyncStateHandler_waitingForValuePromise, "f").resolve(value);
-            __classPrivateFieldGet(this, _AsyncStateHandler_instances, "m", _AsyncStateHandler_fireListeners).call(this);
+            __classPrivateFieldGet(this, _AsyncStateHandler_instances, "m", _AsyncStateHandler_resolveValue).call(this, value);
         }
     })
         .catch((reason) => {
@@ -121,6 +123,16 @@ _AsyncStateHandler_lastTrigger = new WeakMap(), _AsyncStateHandler_resolutionVal
             __classPrivateFieldGet(this, _AsyncStateHandler_instances, "m", _AsyncStateHandler_fireListeners).call(this);
         }
     });
+}, _AsyncStateHandler_resolveValue = function _AsyncStateHandler_resolveValue(value) {
+    if (value !== __classPrivateFieldGet(this, _AsyncStateHandler_resolutionValue, "f")) {
+        __classPrivateFieldSet(this, _AsyncStateHandler_rejectionError, undefined, "f");
+        __classPrivateFieldSet(this, _AsyncStateHandler_resolutionValue, value, "f");
+        if (__classPrivateFieldGet(this, _AsyncStateHandler_waitingForValuePromise, "f").isSettled()) {
+            __classPrivateFieldSet(this, _AsyncStateHandler_waitingForValuePromise, createDeferredPromiseWrapper(), "f");
+        }
+        __classPrivateFieldGet(this, _AsyncStateHandler_waitingForValuePromise, "f").resolve(value);
+        __classPrivateFieldGet(this, _AsyncStateHandler_instances, "m", _AsyncStateHandler_fireListeners).call(this);
+    }
 };
 export class AsyncStateInit {
     constructor(initialValue) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "element-vir",
-    "version": "9.0.1",
+    "version": "9.1.1",
     "keywords": [
         "custom",
         "web",