@qwik.dev/core 2.0.0-beta.3 → 2.0.0-beta.5

package/dist/build/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qwik.dev/core/build",
-  "version": "2.0.0-beta.3-dev+aa098fc",
+  "version": "2.0.0-beta.5-dev+8887f7e",
   "main": "index.mjs",
   "types": "index.d.ts",
   "private": true,

package/dist/cli.cjs

@@ -1,6 +1,6 @@
 /**
  * @license
- * @qwik.dev/core/cli 2.0.0-beta.3-dev+aa098fc
+ * @qwik.dev/core/cli 2.0.0-beta.5-dev+8887f7e
  * 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
@@ -5536,7 +5536,7 @@ async function printHelp(app) {
   await runCommand2(Object.assign(app, { task: args[0], args }));
 }
 function printVersion() {
-  console.log("2.0.0-beta.3-dev+aa098fc");
+  console.log("2.0.0-beta.5-dev+8887f7e");
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/core-internal.d.ts

@@ -1,9 +1,9 @@
+import { ComputedSignal as ComputedSignal_2 } from '..';
 import * as CSS_2 from 'csstype';
 import { isBrowser } from './build';
 import { isDev } from './build';
 import { isServer } from './build';
 import { QRL as QRL_2 } from './qrl.public';
-import { ReadonlySignal as ReadonlySignal_2 } from '..';
 import type { StreamWriter as StreamWriter_2 } from '.';
 import { ValueOrPromise as ValueOrPromise_2 } from '..';
 
@@ -99,7 +99,7 @@ declare type _AllowPlainQrl<Q> = QRLEventHandlerMulti<any, any> extends Q ? Q ex
 
 declare type AllPascalEventMaps = PascalMap<AllEventsMap>;
 
-declare type AllSignalFlags = SignalFlags | WrappedSignalFlags;
+declare type AllSignalFlags = SignalFlags | WrappedSignalFlags | ComputedSignalFlags;
 
 /**
  * TS defines these with the React syntax which is not compatible with Qwik. E.g. `ariaAtomic`
@@ -366,12 +366,43 @@ declare type AsyncComputedCtx = {
 export declare type AsyncComputedFn<T> = (ctx: AsyncComputedCtx) => Promise<T>;
 
 /** @public */
-export declare interface AsyncComputedReadonlySignal<T = unknown> extends ReadonlySignal<T> {
+export declare interface AsyncComputedReadonlySignal<T = unknown> extends ComputedSignal<T> {
 }
 
 /** @public */
 export declare type AsyncComputedReturnType<T> = T extends Promise<infer T> ? AsyncComputedReadonlySignal<T> : AsyncComputedReadonlySignal<T>;
 
+/**
+ * # ================================
+ *
+ * AsyncComputedSignalImpl
+ *
+ * # ================================
+ */
+declare class AsyncComputedSignalImpl<T> extends ComputedSignalImpl<T, AsyncComputeQRL<T>> implements BackRef {
+    $untrackedLoading$: boolean;
+    $untrackedError$: Error | null;
+    $loadingEffects$: null | Set<EffectSubscription>;
+    $errorEffects$: null | Set<EffectSubscription>;
+    $destroy$: NoSerialize<() => void> | null;
+    private $promiseValue$;
+    [_EFFECT_BACK_REF]: Map<EffectProperty | string, EffectSubscription> | null;
+    constructor(container: Container | null, fn: AsyncComputeQRL<T>, flags?: SignalFlags | ComputedSignalFlags);
+    /**
+     * Loading is true if the signal is still waiting for the promise to resolve, false if the promise
+     * has resolved or rejected.
+     */
+    get loading(): boolean;
+    set untrackedLoading(value: boolean);
+    get untrackedLoading(): boolean;
+    /** The error that occurred when the signal was resolved. */
+    get error(): Error | null;
+    set untrackedError(value: Error | null);
+    get untrackedError(): Error | null;
+    invalidate(): void;
+    $computeIfNeeded$(): boolean;
+}
+
 declare type AsyncComputeQRL<T> = QRLInternal<AsyncComputedFn<T>>;
 
 /**
@@ -540,7 +571,13 @@ export declare const componentQrl: <PROPS extends Record<any, any>>(componentQrl
 export declare type ComputedFn<T> = () => T;
 
 /** @public */
-export declare type ComputedReturnType<T> = T extends Promise<any> ? never : ReadonlySignal<T>;
+export declare interface ComputedOptions {
+    serializationStrategy?: SerializationStrategy;
+    container?: Container;
+}
+
+/** @public */
+export declare type ComputedReturnType<T> = T extends Promise<any> ? never : ComputedSignal<T>;
 
 /**
  * A computed signal is a signal which is calculated from other signals. When the signals change,
@@ -551,10 +588,20 @@ export declare type ComputedReturnType<T> = T extends Promise<any> ? never : Rea
  */
 export declare interface ComputedSignal<T> extends ReadonlySignal<T> {
     /**
-     * Use this to force recalculation and running subscribers, for example when the calculated value
-     * mutates but remains the same object. Useful for third-party libraries.
+     * 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;
+}
+
+declare const enum ComputedSignalFlags {
+    SERIALIZATION_STRATEGY_NEVER = 8,
+    SERIALIZATION_STRATEGY_ALWAYS = 16
 }
 
 /**
@@ -570,11 +617,11 @@ declare class ComputedSignalImpl<T, S extends QRLInternal = ComputeQRL<T>> exten
      * resolve the QRL during the mark dirty phase so that any call to it will be synchronous). )
      */
     $computeQrl$: S;
-    $flags$: SignalFlags;
+    $flags$: SignalFlags | ComputedSignalFlags;
     $forceRunEffects$: boolean;
     [_EFFECT_BACK_REF]: Map<EffectProperty | string, EffectSubscription> | null;
-    constructor(container: Container | null, fn: S, flags?: SignalFlags);
-    $invalidate$(): void;
+    constructor(container: Container | null, fn: S, flags?: SignalFlags | ComputedSignalFlags);
+    invalidate(): void;
     /**
      * Use this to force running subscribers, for example when the calculated value has mutated but
      * remained the same object
@@ -789,6 +836,21 @@ export declare interface CorrectedToggleEvent extends Event {
     readonly prevState: 'open' | 'closed';
 }
 
+/**
+ * Create an async computed signal which is calculated from the given QRL. A computed signal is a
+ * signal which is calculated from other signals or async operation. When the signals change, the
+ * computed signal is recalculated.
+ *
+ * The QRL must be a function which returns the value of the signal. The function must not have side
+ * effects, and it can be async.
+ *
+ * @public
+ */
+export declare const createAsyncComputed$: <T>(qrl: () => Promise<T>, options?: ComputedOptions) => AsyncComputedReturnType<T>;
+
+/** @internal */
+export declare const createAsyncComputedQrl: <T>(qrl: QRL<(ctx: AsyncComputedCtx) => Promise<T>>, options?: ComputedOptions) => AsyncComputedSignalImpl<T>;
+
 /**
  * Create a computed signal which is calculated from the given QRL. A computed signal is a signal
  * which is calculated from other signals. When the signals change, the computed signal is
@@ -797,14 +859,14 @@ export declare interface CorrectedToggleEvent extends Event {
  * The QRL must be a function which returns the value of the signal. The function must not have side
  * effects, and it must be synchronous.
  *
- * If you need the function to be async, use `useSignal` and `useTask$` instead.
+ * If you need the function to be async, use `useAsyncComputed$` instead.
  *
  * @public
  */
-export declare const createComputed$: <T>(qrl: () => T) => T extends Promise<any> ? never : ComputedSignal<T>;
+export declare const createComputed$: <T>(qrl: () => T, options?: ComputedOptions) => ComputedReturnType<T>;
 
 /** @internal */
-export declare const createComputedQrl: <T>(qrl: QRL<() => T>) => ComputedSignalImpl<T>;
+export declare const createComputedQrl: <T>(qrl: QRL<() => T>, options?: ComputedOptions) => ComputedSignalImpl<T>;
 
 /**
  * Create a context ID to be used in your application. The name should be written with no spaces.
@@ -1164,6 +1226,9 @@ export declare type FunctionComponent<P = unknown> = {
     renderFn(props: P, key: string | null, flags: number, dev?: DevJSX): JSXOutput;
 }['renderFn'];
 
+/** @internal */
+export declare const _getContextContainer: () => ClientContainer | undefined;
+
 /** @internal */
 export declare const _getContextElement: () => unknown;
 
@@ -1293,7 +1358,7 @@ declare interface HTMLAttributesBase extends AriaAttributes {
 declare type HTMLCrossOriginAttribute = 'anonymous' | 'use-credentials' | '' | undefined;
 
 /** @public */
-export declare interface HTMLElementAttrs extends HTMLAttributesBase, FilterBase<HTMLElement> {
+declare interface HTMLElementAttrs extends HTMLAttributesBase, FilterBase<HTMLElement> {
 }
 
 /** @public */
@@ -2386,6 +2451,13 @@ export declare const render: (parent: Element | Document, jsxNode: JSXOutput | F
 
 declare const RenderEvent = "qRender";
 
+declare interface RenderInvokeContext extends InvokeContext {
+    $hostElement$: HostElement;
+    $event$: PossibleEvents;
+    $waitOn$: Promise<unknown>[];
+    $container$: Container;
+}
+
 /** @public */
 export declare const RenderOnce: FunctionComponent<{
     children?: unknown;
@@ -2601,7 +2673,7 @@ declare interface SerializationContext {
     $addRootPath$: (obj: any) => string | number;
     $seen$: (obj: unknown, parent: unknown | null, index: number) => void;
     $roots$: unknown[];
-    $pathMap$: Map<unknown, string | number>;
+    $objectPathStringCache$: Map<unknown, string | number>;
     $addSyncFn$($funcStr$: string | null, argsCount: number, fn: Function): number;
     $isSsrNode$: (obj: unknown) => obj is SsrNode;
     $isDomRef$: (obj: unknown) => obj is DomRef;
@@ -2616,6 +2688,17 @@ declare interface SerializationContext {
     $setProp$: (obj: any, prop: string, value: any) => void;
 }
 
+/** @public */
+export declare type SerializationStrategy = 'never' | 'always';
+
+declare class SerializationWeakRef {
+    $obj$: unknown;
+    constructor($obj$: unknown);
+}
+
+/** @internal */
+export declare const _serializationWeakRef: (obj: unknown) => SerializationWeakRef;
+
 /**
  * Serialize data to string using SerializationContext.
  *
@@ -3461,7 +3544,7 @@ export declare interface SVGAttributes<T extends Element = Element> extends Aria
 }
 
 /** @public */
-export declare interface SVGProps<T extends Element> extends SVGAttributes, QwikAttributes<T> {
+declare interface SVGProps<T extends Element> extends SVGAttributes, QwikAttributes<T> {
 }
 
 /** @public */
@@ -3630,6 +3713,9 @@ export declare interface Tracker {
     <T extends object, P extends keyof T>(obj: T, prop: P): T[P];
 }
 
+/** @internal */
+export declare const _UNINITIALIZED: unique symbol;
+
 /**
  * Don't track listeners for this callback
  *
@@ -3657,10 +3743,10 @@ export declare const unwrapStore: <T>(value: T) => T;
  *
  * @public
  */
-export declare const useAsyncComputed$: <T>(qrl: AsyncComputedFn<T>) => AsyncComputedReturnType<T>;
+export declare const useAsyncComputed$: <T>(qrl: AsyncComputedFn<T>, options?: ComputedOptions | undefined) => AsyncComputedReturnType<T>;
 
 /** @internal */
-export declare const useAsyncComputedQrl: <T>(qrl: QRL<AsyncComputedFn<T>>) => AsyncComputedReturnType<T>;
+export declare const useAsyncComputedQrl: <T>(qrl: QRL<AsyncComputedFn<T>>, options?: ComputedOptions) => AsyncComputedReturnType<T>;
 
 /**
  * Creates a computed signal which is calculated from the given function. A computed signal is a
@@ -3672,10 +3758,10 @@ export declare const useAsyncComputedQrl: <T>(qrl: QRL<AsyncComputedFn<T>>) => A
  *
  * @public
  */
-export declare const useComputed$: <T>(qrl: ComputedFn<T>) => ComputedReturnType<T>;
+export declare const useComputed$: <T>(qrl: ComputedFn<T>, options?: ComputedOptions | undefined) => ComputedReturnType<T>;
 
 /** @internal */
-export declare const useComputedQrl: <T>(qrl: QRL<ComputedFn<T>>) => ComputedReturnType<T>;
+export declare const useComputedQrl: <T>(qrl: QRL<ComputedFn<T>>, options?: ComputedOptions) => ComputedReturnType<T>;
 
 /**
  * Stores a value which is retained for the lifetime of the component. Subsequent calls to
@@ -3800,6 +3886,9 @@ export declare const useErrorBoundary: () => ErrorBoundaryStore;
 /** @public */
 export declare const useId: () => string;
 
+/** @internal */
+export declare const _useInvokeContext: () => RenderInvokeContext;
+
 /**
  * Used by the Qwik Optimizer to restore the lexically scoped variables.
  *
@@ -4001,7 +4090,7 @@ export declare const useResourceQrl: <T>(qrl: QRL<ResourceFn<T>>, opts?: Resourc
 export declare const useSerializer$: typeof createSerializer$;
 
 /** @internal */
-export declare const useSerializerQrl: <T, S>(qrl: QRL<SerializerArg<T, S>>) => ReadonlySignal_2<unknown>;
+export declare const useSerializerQrl: <T, S>(qrl: QRL<SerializerArg<T, S>>) => ComputedSignal_2<unknown>;
 
 /** @public */
 export declare function useServerData<T>(key: string): T | undefined;
@@ -4249,7 +4338,7 @@ export declare const _VAR_PROPS: unique symbol;
 export declare const _verifySerializable: <T>(value: T, preMessage?: string) => T;
 
 /**
- * 2.0.0-beta.3-dev+aa098fc
+ * 2.0.0-beta.5-dev+8887f7e
  *
  * @public
  */
@@ -4389,9 +4478,6 @@ export declare function _walkJSX(ssr: SSRContainer, value: JSXOutput, options: {
     parentComponentFrame: ISsrComponentFrame | null;
 }): Promise<void>;
 
-/** @internal */
-export declare const _weakSerialize: <T extends object>(input: T) => Partial<T>;
-
 /**
  * Override the `getLocale` with `lang` within the `fn` execution.
  *
@@ -4412,7 +4498,7 @@ declare class WrappedSignalImpl<T> extends SignalImpl<T> implements BackRef {
     $forceRunEffects$: boolean;
     [_EFFECT_BACK_REF]: Map<EffectProperty | string, EffectSubscription> | null;
     constructor(container: Container | null, fn: (...args: any[]) => T, args: any[], fnStr: string | null, flags?: SignalFlags);
-    $invalidate$(): void;
+    invalidate(): void;
     /**
      * Use this to force running subscribers, for example when the calculated value has mutated but
      * remained the same object.
@@ -4440,7 +4526,4 @@ export declare const _wrapProp: <T extends Record<any, any>, P extends keyof T>(
 /** @internal @deprecated v1 compat */
 export declare const _wrapSignal: <T extends Record<any, any>, P extends keyof T>(obj: T, prop: P) => any;
 
-/** @internal */
-export declare const _wrapStore: <T extends Record<any, any>, P extends keyof T>(obj: T, prop: P) => Signal<T>;
-
 export { }