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

package/dist/server.mjs

@@ -1,6 +1,6 @@
 /**
  * @license
- * @qwik.dev/core/server 2.0.0-beta.21-dev+c008e88
+ * @qwik.dev/core/server 2.0.0-beta.23-dev+03de42d
  * Copyright QwikDev. All Rights Reserved.
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://github.com/QwikDev/qwik/blob/main/LICENSE
@@ -1202,13 +1202,16 @@ function getBuildBase(opts) {
   return `${import.meta.env.BASE_URL || "/"}build/`;
 }
 var versions = {
-  qwik: "2.0.0-beta.21-dev+c008e88",
+  qwik: "2.0.0-beta.23-dev+03de42d",
   qwikDom: "2.1.19"
 };
 
 // packages/qwik/src/server/ssr-container.ts
 import { isDev as isDev6 } from "@qwik.dev/core/build";
 import {
+  _createQRL as createQRL,
+  _qrlToString as qrlToString,
+  _res,
   _SubscriptionData as SubscriptionData,
   _SharedContainer,
   _jsxSorted,
@@ -2726,11 +2729,24 @@ var SSRContainer = class extends _SharedContainer {
     if (!this.serializationCtx.$roots$.length) {
       return;
     }
-    this.openElement("script", null, ["type", "qwik/state"]);
+    const attrs = this.stateScriptAttrs();
+    this.openElement("script", null, attrs);
     return maybeThen(this.serializationCtx.$serialize$(), () => {
       this.closeElement();
     });
   }
+  /** Add q-d:qidle attribute to eagerly resume some state if needed */
+  stateScriptAttrs() {
+    const attrs = ["type", "qwik/state"];
+    const eagerResume = this.serializationCtx.$eagerResume$;
+    if (eagerResume.size > 0) {
+      const qrl = createQRL(null, "_res", _res, null, [...eagerResume]);
+      const qrlStr = qrlToString(this.serializationCtx, qrl);
+      attrs.push("q-d:qidle", qrlStr);
+      this.serializationCtx.$eventNames$.add("d:qidle");
+    }
+    return attrs;
+  }
   emitSyncFnsData() {
     const fns = this.serializationCtx.$syncFns$;
     if (fns.length) {
@@ -3109,13 +3125,12 @@ var renderToStream = async (jsx, opts) => {
   await ssrContainer.$renderPromise$;
   flush();
   const snapshotResult = getSnapshotResult(ssrContainer);
-  const isDynamic = snapshotResult.resources.some((r) => r._cache !== Infinity);
   const result = {
     snapshotResult,
     flushes: networkFlushes,
     manifest: resolvedManifest?.manifest,
     size: ssrContainer.size,
-    isStatic: !isDynamic,
+    isStatic: false,
     timing
   };
   return result;

package/dist/testing/index.d.ts

@@ -16,7 +16,40 @@ declare interface AddRootFn {
     (obj: unknown, returnRef: true): SeenRef;
 }
 
-declare type AllSignalFlags = SignalFlags | WrappedSignalFlags | SerializationSignalFlags;
+declare type AllSignalFlags = SignalFlags | WrappedSignalFlags | SerializationSignalFlags | AsyncSignalFlags;
+
+/** @public */
+declare interface AsyncSignal<T = unknown> extends ComputedSignal<T> {
+    /**
+     * Whether the signal is currently loading. This will trigger lazy loading of the signal, so you
+     * can use it like this:
+     *
+     * ```tsx
+     * signal.loading ? <Loading /> : signal.error ? <Error /> : <Component
+     * value={signal.value} />
+     * ```
+     */
+    loading: boolean;
+    /**
+     * The error that occurred while computing the signal, if any. This will be cleared when the
+     * signal is successfully computed.
+     */
+    error: Error | undefined;
+    /**
+     * Poll interval in ms. Writable and immediately effective when the signal has consumers. If set
+     * to `0`, polling stops.
+     */
+    interval: number;
+    /** A promise that resolves when the value is computed or rejected. */
+    promise(): Promise<void>;
+    /** Abort the current computation and run cleanups if needed. */
+    abort(reason?: any): void;
+}
+
+declare const enum AsyncSignalFlags {
+    EAGER_CLEANUP = 32,
+    AWAIT_PREVIOUS = 64
+}
 
 /** Class for back reference to the EffectSubscription */
 declare abstract class BackRef {
@@ -45,6 +78,26 @@ declare const enum ChoreBits {
     DIRTY_MASK = 127
 }
 
+/**
+ * A computed signal is a signal which is calculated from other signals. When the signals change,
+ * the computed signal is recalculated, and if the result changed, all tasks which are tracking the
+ * signal will be re-run and all components that read the signal will be re-rendered.
+ *
+ * @public
+ */
+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.
+     */
+    force(): void;
+    /**
+     * Use this to force recalculation and running subscribers, for example when the calculated value
+     * mutates but remains the same object.
+     */
+    invalidate(): void;
+}
+
 /**
  * Effect is something which needs to happen (side-effect) due to signal value change.
  *
@@ -67,8 +120,8 @@ declare interface Container {
     $buildBase$: string | null;
     $renderPromise$: Promise<void> | null;
     $resolveRenderPromise$: (() => void) | null;
-    $cursorCount$: number;
-    $pausedCursorCount$: number;
+    $pendingCount$: number;
+    $checkPendingCount$(): void;
     handleError(err: any, $host$: HostElement | null): void;
     getParentHost(host: HostElement): HostElement | null;
     setContext<T>(host: HostElement, context: ContextId<T>, value: T): void;
@@ -179,7 +232,7 @@ declare interface DescriptorBase<T = unknown, B = unknown> extends BackRef {
     $el$: HostElement;
     $qrl$: QRLInternal<T>;
     $state$: B | undefined;
-    $destroy$: NoSerialize<() => void> | null;
+    $destroy$: (() => void) | null;
 }
 
 declare type DomRef = {
@@ -337,19 +390,9 @@ declare interface NodePropData {
     $isConst$: boolean;
 }
 
-/**
- * Returned type of the `noSerialize()` function. It will be TYPE or undefined.
- *
- * @public
- * @see noSerialize
- */
-declare type NoSerialize<T> = (T & {
-    __no_serialize__: true;
-}) | undefined;
-
 declare type ObjToProxyMap = WeakMap<any, any>;
 
-declare type PossibleEvents = Event | SimplifiedServerRequestEvent | typeof TaskEvent | typeof RenderEvent | typeof ResourceEvent;
+declare type PossibleEvents = Event | SimplifiedServerRequestEvent | typeof TaskEvent | typeof RenderEvent;
 
 declare type Props = Record<string, unknown>;
 
@@ -531,18 +574,13 @@ declare interface ReadonlySignal<T = unknown> {
 
 declare const RenderEvent = "qRender";
 
-declare const ResourceEvent = "qResource";
-
 declare interface ResourceReturnInternal<T> {
     __brand: 'resource';
-    _state: 'pending' | 'resolved' | 'rejected';
-    _resolved: T | undefined;
-    _error: Error | undefined;
-    _cache: number;
-    _timeout: number;
-    _generation: number;
     value: Promise<T>;
     loading: boolean;
+    signal: AsyncSignal<{
+        r: T;
+    }>;
 }
 
 /** Stores the location of an object. If no parent, it's a root. */
@@ -552,7 +590,7 @@ declare type SeenRef = {
 };
 
 declare interface SerializationContext {
-    $serialize$: () => void;
+    $serialize$: () => ValueOrPromise<void>;
     $symbolToChunkResolver$: SymbolToChunkResolver;
     /**
      * Map from object to parent and index reference.
@@ -586,9 +624,10 @@ declare interface SerializationContext {
     $syncFns$: string[];
     $eventQrls$: Set<QRL>;
     $eventNames$: Set<string>;
-    $resources$: Set<ResourceReturnInternal<unknown>>;
     $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;
 }
@@ -700,14 +739,14 @@ declare class SubscriptionData {
 
 declare type SymbolToChunkResolver = (symbol: string) => string;
 
-declare class Task<T = unknown, B = T> extends BackRef implements DescriptorBase<unknown, Signal<B> | ResourceReturnInternal<B>> {
+declare class Task<T = unknown, B = T> extends BackRef implements DescriptorBase<unknown, Signal<B>> {
     $flags$: number;
     $index$: number;
     $el$: HostElement;
     $qrl$: QRLInternal<T>;
-    $state$: Signal<B> | ResourceReturnInternal<B> | undefined;
-    $destroy$: NoSerialize<() => void> | null;
-    constructor($flags$: number, $index$: number, $el$: HostElement, $qrl$: QRLInternal<T>, $state$: Signal<B> | ResourceReturnInternal<B> | undefined, $destroy$: NoSerialize<() => void> | null);
+    $state$: Signal<B> | undefined;
+    $destroy$: (() => void) | null;
+    constructor($flags$: number, $index$: number, $el$: HostElement, $qrl$: QRLInternal<T>, $state$: Signal<B> | undefined, $destroy$: (() => void) | null);
 }
 
 declare const TaskEvent = "qTask";
@@ -895,11 +934,6 @@ declare class WrappedSignalImpl<T> extends SignalImpl<T> implements BackRef {
     [_EFFECT_BACK_REF]: Map<EffectProperty | string, EffectSubscription> | undefined;
     constructor(container: Container | null, fn: (...args: any[]) => T, args: any[], fnStr: string | null, flags?: SignalFlags);
     invalidate(): void;
-    /**
-     * Use this to force running subscribers, for example when the calculated value has mutated but
-     * remained the same object.
-     */
-    force(): void;
     get untrackedValue(): T;
     $computeIfNeeded$(): void;
     $unwrapIfSignal$(): SignalImpl<T> | WrappedSignalImpl<T>;