@qwik.dev/core 2.0.0-beta.23 → 2.0.0-beta.24

package/dist/core-internal.d.ts

@@ -398,7 +398,30 @@ declare class AsyncJob<T> implements AsyncCtx<T> {
 
 declare type AsyncQRL<T> = _QRLInternal<AsyncFn<T>>;
 
-/** @public */
+/**
+ * An AsyncSignal holds the result of the given async function. If the function uses `track()` to
+ * track reactive state, and that state changes, the AsyncSignal is recalculated, and if the result
+ * changed, all tasks which are tracking the AsyncSignal will be re-run and all subscribers
+ * (components, tasks etc) that read the AsyncSignal will be updated.
+ *
+ * If the async function throws an error, the AsyncSignal will capture the error and set the `error`
+ * property. The error can be cleared by re-running the async function successfully.
+ *
+ * While the async function is running, the `.loading` property will be set to `true`. Once the
+ * function completes, `loading` will be set to `false`.
+ *
+ * If the value has not yet been resolved, reading the AsyncSignal will throw a Promise, which will
+ * retry the component or task once the value resolves.
+ *
+ * If the value has been resolved, but the async function is re-running, reading the AsyncSignal
+ * will subscribe to it and return the last resolved value until the new value is ready. As soon as
+ * the new value is ready, the subscribers will be updated.
+ *
+ * If the async function threw an error, reading the `.value` will throw that same error. Read from
+ * `.error` to check if there was an error.
+ *
+ * @public
+ */
 export declare interface AsyncSignal<T = unknown> extends ComputedSignal<T> {
     /**
      * Whether the signal is currently loading. This will trigger lazy loading of the signal, so you
@@ -428,7 +451,7 @@ export declare interface AsyncSignal<T = unknown> extends ComputedSignal<T> {
 
 declare const enum AsyncSignalFlags {
     EAGER_CLEANUP = 32,
-    AWAIT_PREVIOUS = 64
+    CLIENT_ONLY = 64
 }
 
 /**
@@ -447,11 +470,13 @@ declare class AsyncSignalImpl<T> extends ComputedSignalImpl<T, AsyncQRL<T>> impl
     $jobs$: AsyncJob<T>[];
     $concurrency$: number;
     $interval$: number;
-    $pollTimeoutId$: ReturnType<typeof setTimeout> | undefined;
     $timeoutMs$: number | undefined;
+    $pollTimeoutId$: ReturnType<typeof setTimeout> | undefined;
     $computationTimeoutId$: ReturnType<typeof setTimeout> | undefined;
     [_EFFECT_BACK_REF]: Map<EffectProperty | string, EffectSubscription> | undefined;
     constructor(container: _Container | null, fn: AsyncQRL<T>, flags?: SignalFlags | SerializationSignalFlags, options?: AsyncSignalOptions<T>);
+    get untrackedValue(): T;
+    set untrackedValue(value: T);
     /**
      * Loading is true if the signal is still waiting for the promise to resolve, false if the promise
      * has resolved or rejected.
@@ -481,7 +506,6 @@ declare class AsyncSignalImpl<T> extends ComputedSignalImpl<T, AsyncQRL<T>> impl
     $runComputation$(running: AsyncJob<T>): Promise<void>;
     /** Called after SSR/unmount */
     $destroy$(): Promise<void>;
-    get untrackedValue(): T;
     private $clearNextPoll$;
     private $scheduleNextPoll$;
     private $hasSubscribers$;
@@ -522,6 +546,13 @@ export declare interface AsyncSignalOptions<T> extends ComputedOptions {
      * Defaults to `0`.
      */
     interval?: number;
+    /**
+     * When true, the async computation is postponed to the browser. On SSR, the signal remains
+     * INVALID and does not execute the function. On the client, it will compute on first read.
+     *
+     * Defaults to `false`.
+     */
+    clientOnly?: boolean;
     /**
      * Maximum time in milliseconds to wait for the async computation to complete. If exceeded, the
      * computation is aborted and an error is thrown.
@@ -722,16 +753,10 @@ export declare type ComputedReturnType<T> = T extends Promise<any> ? never : Com
  *
  * @public
  */
-export declare interface ComputedSignal<T> extends ReadonlySignal<T> {
-    /**
-     * Use this to force running subscribers, for example when the calculated value mutates but
-     * remains the same object.
-     */
+export declare interface ComputedSignal<T> extends Signal<T> {
+    /** @deprecated Use `trigger()` instead */
     force(): void;
-    /**
-     * Use this to force recalculation and running subscribers, for example when the calculated value
-     * mutates but remains the same object.
-     */
+    /** Use this to force recalculation. */
     invalidate(): void;
 }
 
@@ -753,6 +778,7 @@ declare class ComputedSignalImpl<T, S extends _QRLInternal = ComputeQRL<T>> exte
     constructor(container: _Container | null, fn: S, flags?: SignalFlags | SerializationSignalFlags);
     invalidate(): void;
     get untrackedValue(): T;
+    set untrackedValue(value: T);
     $computeIfNeeded$(): void;
 }
 
@@ -1245,6 +1271,9 @@ export declare class _ElementVNode extends _VirtualVNode {
 /** @internal */
 export declare const _EMPTY_ARRAY: any[];
 
+/** @internal */
+export declare const _EMPTY_OBJ: Record<string, any>;
+
 /** @public */
 declare type EntryStrategy = InlineEntryStrategy | HoistEntryStrategy | SingleEntryStrategy | HookEntryStrategy | SegmentEntryStrategy | ComponentEntryStrategy | SmartEntryStrategy;
 
@@ -1616,7 +1645,7 @@ declare interface ISsrNode {
 }
 
 /** @internal */
-export declare const _isStore: (value: StoreTarget) => boolean;
+export declare const _isStore: (value: object) => boolean;
 
 /** @internal */
 export declare function _isStringifiable(value: unknown): value is _Stringifiable;
@@ -1624,6 +1653,13 @@ export declare function _isStringifiable(value: unknown): value is _Stringifiabl
 /** @internal */
 export declare const _isTask: (value: any) => value is Task;
 
+/** @internal */
+declare interface IStreamHandler {
+    flush(): void;
+    streamBlockStart(): void;
+    streamBlockEnd(): void;
+}
+
 /**
  * Used by the JSX transpilers to create a JSXNode. Note that the optimizer will normally not use
  * this, instead using _jsxSplit and _jsxSorted directly.
@@ -2655,7 +2691,7 @@ export declare type QwikWheelEvent<T = Element> = NativeWheelEvent;
 
 declare type QwikWindowEventMap = Omit<WindowEventHandlersEventMap, keyof QwikDocumentEventMap> & QwikDocumentEventMap;
 
-/** @public */
+/** @public @deprecated not used */
 export declare interface ReadonlySignal<T = unknown> {
     readonly value: T;
 }
@@ -2908,14 +2944,13 @@ declare interface SerializationContext {
     $renderSymbols$: Set<string>;
     $storeProxyMap$: ObjToProxyMap;
     $eagerResume$: Set<unknown>;
-    $resources$: Set<ResourceReturnInternal<any>>;
-    $getProp$: (obj: any, prop: string) => any;
     $setProp$: (obj: any, prop: string, value: any) => void;
 }
 
 declare const enum SerializationSignalFlags {
     SERIALIZATION_STRATEGY_NEVER = 8,
-    SERIALIZATION_STRATEGY_ALWAYS = 16
+    SERIALIZATION_STRATEGY_ALWAYS = 16,
+    SERIALIZATION_ALL_STRATEGIES = 24
 }
 
 /**
@@ -3034,6 +3069,9 @@ export declare const SerializerSymbol: unique symbol;
  */
 declare type ServerQwikManifest = Pick<QwikManifest, 'manifestHash' | 'injections' | 'bundleGraph' | 'bundleGraphAsset' | 'mapping' | 'preloader' | 'core' | 'qwikLoader'>;
 
+/** @internal */
+export declare function _setEvent(serializationCtx: SerializationContext, key: string, rawValue: unknown, isLoopElement: boolean): string | null;
+
 /**
  * Sets the `CorePlatform`.
  *
@@ -3093,8 +3131,16 @@ export declare abstract class _SharedContainer implements _Container {
  *
  * @public
  */
-export declare interface Signal<T = any> extends ReadonlySignal<T> {
+export declare interface Signal<T = any> {
+    /** Reading from this subscribes to updates; writing to this triggers updates. */
     value: T;
+    /** Reading from this does not subscribe to updates; writing to this does not trigger updates. */
+    untrackedValue: T;
+    /**
+     * Use this to trigger running subscribers, for example when the value mutated but remained the
+     * same object.
+     */
+    trigger(): void;
 }
 
 declare const enum SignalFlags {
@@ -3110,9 +3156,11 @@ declare class SignalImpl<T = any> implements Signal<T> {
     $wrappedSignal$: WrappedSignalImpl<T> | null;
     constructor(container: _Container | null, value: T);
     /**
-     * Use this to force running subscribers, for example when the calculated value has mutated but
+     * Use this to trigger running subscribers, for example when the calculated value has mutated but
      * remained the same object
      */
+    trigger(): void;
+    /** @deprecated Use `trigger()` instead */
     force(): void;
     get untrackedValue(): T;
     set untrackedValue(value: T);
@@ -3125,8 +3173,6 @@ declare class SignalImpl<T = any> implements Signal<T> {
     };
 }
 
-declare type SimpleSsrAttrValue = string | Signal<SimpleSsrAttrValue> | boolean | object | null;
-
 declare interface SimplifiedServerRequestEvent<T = unknown> {
     url: URL;
     locale: string | undefined;
@@ -3402,12 +3448,6 @@ declare type SpecialAttrs = {
     [key: string]: {};
 };
 
-declare type SsrAttrKey = string;
-
-declare type SsrAttrs = Array<SsrAttrKey | SsrAttrValue>;
-
-declare type SsrAttrValue = SimpleSsrAttrValue | Promise<SimpleSsrAttrValue>;
-
 /** @public */
 export declare const SSRComment: FunctionComponent<{
     data: string;
@@ -3418,6 +3458,7 @@ declare interface SSRContainer extends _Container {
     readonly isHtml: boolean;
     readonly size: number;
     readonly writer: StreamWriter;
+    readonly streamHandler: IStreamHandler;
     readonly serializationCtx: SerializationContext;
     readonly symbolToChunkResolver: SymbolToChunkResolver;
     readonly resolvedManifest: ResolvedManifest;
@@ -3426,13 +3467,13 @@ declare interface SSRContainer extends _Container {
     write(text: string): void;
     openContainer(): void;
     closeContainer(): ValueOrPromise<void>;
-    openElement(elementName: string, key: string | null, varAttrs: SsrAttrs | null, constAttrs?: SsrAttrs | null, currentFile?: string | null): string | undefined;
+    openElement(elementName: string, key: string | null, varAttrs: Props, constAttrs: Props | null, styleScopedId: string | null, currentFile: string | null): string | undefined;
     closeElement(): ValueOrPromise<void>;
-    openFragment(attrs: SsrAttrs): void;
+    openFragment(attrs: Props): void;
     closeFragment(): void;
-    openProjection(attrs: SsrAttrs): void;
+    openProjection(attrs: Props): void;
     closeProjection(): void;
-    openComponent(attrs: SsrAttrs): void;
+    openComponent(attrs: Props): void;
     getComponentFrame(projectionDepth: number): ISsrComponentFrame | null;
     getParentComponentFrame(): ISsrComponentFrame | null;
     closeComponent(): Promise<void>;
@@ -4636,7 +4677,7 @@ export declare const _VAR_PROPS: unique symbol;
 export declare const _verifySerializable: <T>(value: T, preMessage?: string) => T;
 
 /**
- * 2.0.0-beta.23-dev+03de42d
+ * 2.0.0-beta.24-dev+314726b
  *
  * @public
  */
@@ -4717,7 +4758,7 @@ export declare function _vnode_toString(this: _VNode | null, depth?: number, off
  * this data needs to be serialized into a string and stored in the DOM as a script tag which has
  * deferent serialization format.
  */
-declare type VNodeData = [VNodeDataFlag, ...(SsrAttrs | number)[]];
+declare type VNodeData = [VNodeDataFlag, ...(Props | number)[]];
 
 /**
  * Flags for VNodeData (Flags con be bitwise combined)
@@ -4795,7 +4836,7 @@ declare const enum WrappedSignalFlags {
     UNWRAP = 4
 }
 
-declare class WrappedSignalImpl<T> extends SignalImpl<T> implements BackRef {
+declare class WrappedSignalImpl<T> extends SignalImpl<T> {
     $args$: any[];
     $func$: (...args: any[]) => T;
     $funcStr$: string | null;