@qwik.dev/core 2.0.0-beta.40 → 2.0.0-beta.42

package/dist/backpatch/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qwik.dev/core/backpatch",
-  "version": "2.0.0-beta.40-dev+a459d55",
+  "version": "2.0.0-beta.42-dev+3473a49",
   "main": "index.mjs",
   "types": "index.d.ts",
   "private": true,

package/dist/build/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qwik.dev/core/build",
-  "version": "2.0.0-beta.40-dev+a459d55",
+  "version": "2.0.0-beta.42-dev+3473a49",
   "main": "index.mjs",
   "types": "index.d.ts",
   "private": true,

package/dist/cli.mjs

@@ -1,6 +1,6 @@
 /**
  * @license
- * @qwik.dev/core/cli 2.0.0-beta.40-dev+a459d55
+ * @qwik.dev/core/cli 2.0.0-beta.42-dev+3473a49
  * 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
@@ -12966,7 +12966,7 @@ async function printHelp(app) {
   await runCommand2(Object.assign(app, { task: args[0], args }));
 }
 function printVersion() {
-  console.log("2.0.0-beta.40-dev+a459d55");
+  console.log("2.0.0-beta.42-dev+3473a49");
 }
 export {
   runCli,

package/dist/core-internal.d.ts

@@ -367,17 +367,13 @@ declare interface AriaAttributes {
 declare type AriaRole = 'alert' | 'alertdialog' | 'application' | 'article' | 'banner' | 'button' | 'cell' | 'checkbox' | 'columnheader' | 'combobox' | 'complementary' | 'contentinfo' | 'definition' | 'dialog' | 'directory' | 'document' | 'feed' | 'figure' | 'form' | 'grid' | 'gridcell' | 'group' | 'heading' | 'img' | 'link' | 'list' | 'listbox' | 'listitem' | 'log' | 'main' | 'marquee' | 'math' | 'menu' | 'menubar' | 'menuitem' | 'menuitemcheckbox' | 'menuitemradio' | 'navigation' | 'none' | 'note' | 'option' | 'presentation' | 'progressbar' | 'radio' | 'radiogroup' | 'region' | 'row' | 'rowgroup' | 'rowheader' | 'scrollbar' | 'search' | 'searchbox' | 'separator' | 'slider' | 'spinbutton' | 'status' | 'switch' | 'tab' | 'table' | 'tablist' | 'tabpanel' | 'term' | 'textbox' | 'timer' | 'toolbar' | 'tooltip' | 'tree' | 'treegrid' | 'treeitem' | (string & {});
 
 /**
- * Note, we don't pass the generic type to ComputeCtx because it causes TypeScript to not infer the
- * type of the resource correctly. The type is only used for the `previous` property, which is not
- * commonly used, and can be easily cast if needed.
- *
- * @deprecated Use `useComputed$` with an async function instead.
+ * @deprecated Use `ComputedFn` instead.
  * @public
  */
-export declare type AsyncFn<T> = (ctx: ComputeCtx) => ValueOrPromise<T>;
+export declare type AsyncFn<T> = ComputedFn<T>;
 
 /** @deprecated Use `ComputeQRL` instead. */
-declare type AsyncQRL<T> = _QRLInternal<AsyncFn<T>>;
+declare type AsyncQRL<T> = ComputeQRL<T>;
 
 /**
  * An AsyncSignal holds the result of the given async function. If the function uses `track()` to
@@ -844,9 +840,9 @@ declare class ComputedSignalImpl<T, S extends _QRLInternal = ComputeQRL<T>> exte
     /** Run the computation if needed */
     $computeIfNeeded$(): void;
     /**
-     * Invoke the compute fn with the ComputeCtx argument. CTX_ARG signals (useAsync$, useResource$)
-     * only track via its explicit track(). Computeds auto-track every synchronous read instead; after
-     * the first await they must use the explicit track() too.
+     * Invoke the compute fn with the ComputeCtx argument. CTX_ARG signals (createAsyncQrl,
+     * useResource$) only track via its explicit track(). Computeds auto-track every synchronous read
+     * instead; after the first await they must use the explicit track() too.
      */
     $invokeComputeFn$(fn: Function, job: Job<T>): T | Promise<T>;
     /** Start an async computation (the async engine; assumes the INVALID flag is set) */
@@ -901,7 +897,7 @@ export declare interface _Container {
     $resolveRenderPromise$: (() => void) | null;
     $pendingCount$: number;
     $checkPendingCount$(): void;
-    handleError(err: any, $host$: _HostElement | null): void;
+    handleError(err: any, $host$: _HostElement | null, phase?: ErrorBoundaryPhase): void;
     getParentHost(host: _HostElement): _HostElement | null;
     setContext<T>(host: _HostElement, context: ContextId<T>, value: T): void;
     resolveContext<T>(host: _HostElement, contextId: ContextId<T>): T | undefined;
@@ -1083,17 +1079,8 @@ export declare interface CorrectedToggleEvent extends Event {
     readonly prevState: 'open' | 'closed';
 }
 
-/**
- * Create a signal holding a `.value` which is calculated from the given async function (QRL). The
- * standalone version of `useAsync$`.
- *
- * @deprecated Use `createComputed$` instead, it has async support now.
- * @public
- */
-export declare const createAsync$: <T>(qrl: (arg: ComputeCtx<T>) => Promise<T>, options?: AsyncSignalOptions<T>) => AsyncSignal<T>;
-
 /** @internal */
-export declare const createAsyncQrl: <T>(qrl: QRL<AsyncFn<T>>, options?: AsyncSignalOptions<T>) => _AsyncSignalImpl<T>;
+export declare const createAsyncQrl: <T>(qrl: QRL<ComputedFn<T>>, options?: AsyncSignalOptions<T>) => _AsyncSignalImpl<T>;
 
 /**
  * Create a computed signal which is calculated from the given QRL. A computed signal is a signal
@@ -1305,9 +1292,10 @@ declare class DomContainer extends _SharedContainer implements ClientContainer {
     $hoistStyles$(): void;
     $setRawState$(id: number, vParent: _VNode): void;
     parseQRL<T = unknown>(qrlStr: string): QRL<T>;
-    handleError(err: any, host: _VNode | null): void;
+    handleError(err: any, host: _VNode | null, phase?: ErrorBoundaryPhase): void;
     setContext<T>(host: _VNode, context: ContextId<T>, value: T): void;
     resolveContext<T>(host: _VNode, contextId: ContextId<T>): T | undefined;
+    resolveContextHost(host: _VNode, contextId: ContextId<unknown>): _VNode | null;
     getParentHost(host: _VNode): _VNode | null;
     setHostProp<T>(host: _HostElement, name: string, value: T): void;
     getHostProp<T>(host: _HostElement, name: string): T | null;
@@ -1346,6 +1334,12 @@ declare interface EachProps<T, ITEM extends JSXOutput = JSXOutput> {
 /** @internal */
 export declare const _eaT: ({ track }: TaskCtx) => Promise<void>;
 
+/** @internal */
+export declare const _ebC: (props: ErrorBoundaryProps) => JSXOutput;
+
+/** @internal */
+export declare const _ebR: () => void;
+
 /** @internal */
 export declare const _EFFECT_BACK_REF: unique symbol;
 
@@ -1417,9 +1411,55 @@ export declare const _EMPTY_ARRAY: any[];
 /** @internal */
 export declare const _EMPTY_OBJ: Record<string, any>;
 
-/** @public */
-export declare interface ErrorBoundaryStore {
-    error: any | undefined;
+/** Renders `fallback$` instead of its children when a descendant throws. @public @experimental */
+export declare const ErrorBoundary: Component<ErrorBoundaryProps>;
+
+/** Structured metadata about a caught error, passed to `onError$`. @public @experimental */
+export declare interface ErrorBoundaryInfo {
+    /** Where the caught error originated. */
+    phase: ErrorBoundaryPhase;
+    /**
+     * Identifies the boundary within the page. Allocated in render order and kept across a resume, so
+     * every report from one boundary shares it — but it shifts when render order changes.
+     */
+    boundaryId: string;
+    /**
+     * The code a production fallback shows for a server-origin error, so a user's bug report matches
+     * your logs. An error caught during SSR reports a second, different digest if the client
+     * re-derives it — the stacks differ.
+     */
+    digest: string;
+}
+
+/** Identifies where an error caught by an error boundary originated. @public @experimental */
+export declare const enum ErrorBoundaryPhase {
+    Render = "render",
+    Event = "event",
+    Hook = "hook"
+}
+
+/** @public @experimental */
+export declare interface ErrorBoundaryProps {
+    /**
+     * Rendered when a descendant throws. The error is always an `Error`, so `{error.message}` is
+     * safe: a non-Error throw is wrapped, and production redacts server-origin errors to a generic
+     * message plus `digest`. Client-origin errors render as thrown — their messages already live in
+     * the browser bundle.
+     *
+     * Wrap `reset` in a handler — `onClick$={() => reset()}`, not `onClick$={reset}` — so it stays
+     * wired in a streamed fallback.
+     */
+    fallback$: QRL<(error: Error & {
+        digest?: string;
+    }, reset: QRL<() => void>) => JSXOutput>;
+    /**
+     * Side effect only; never affects rendering. Receives the original `Error` — a non-Error throw
+     * arrives wrapped, with `cause` set to the raw value.
+     *
+     * An error caught during SSR fires again when the client re-derives it, so dedupe in your
+     * reporter.
+     */
+    onError$?: QRL<(error: Error, info: ErrorBoundaryInfo) => void>;
 }
 
 /** @public */
@@ -1559,6 +1599,9 @@ declare function h<TYPE extends string | FunctionComponent<PROPS>, PROPS extends
 export { h as createElement }
 export { h }
 
+/** @internal */
+export declare function _handleSSRError(container: SSRContainer, err: any, host: ISsrNode | null, phase: ErrorBoundaryPhase): void;
+
 /**
  * @returns True if the store has effects for the given prop
  * @internal
@@ -1773,6 +1816,9 @@ declare interface InvokeContext {
     $container$: _Container | undefined;
 }
 
+declare class InvokeJSXFunction {
+}
+
 declare type IsAcceptableDOMValue<T> = T extends boolean | number | string | null | undefined ? ((...args: any[]) => any) extends T ? false : true : false;
 
 declare type IsAny<T> = 0 extends T & 1 ? true : false;
@@ -2468,7 +2514,9 @@ export declare interface _QDocument extends Document {
     /** Processes one vnode patch script. */
     qProcessVNodeDataPatch?: (script: Element | null) => void;
     /** Processes an out-of-order Suspense segment after its resolved HTML is swapped in. */
-    qProcessOOOS?: (boundaryId: number, content: Element | null) => void;
+    qProcessOOOS?: (boundaryId: number, revealNode: Element | null) => void;
+    /** Routes `qerror` to the owning container; installed once per document, shared by all bundles. */
+    qErrorHandler?: (e: Event) => void;
 }
 
 /**
@@ -2903,10 +2951,10 @@ export declare interface ReadonlySignal<T = unknown> {
 }
 
 /** @internal */
-export declare const _reC: (props: RevealProps) => JSXNodeInternal<InternalServerComponent<SSRRevealSlotProps>> | JSXNodeInternal<FunctionComponent<    {
+export declare const _reC: (props: RevealProps) => JSXNodeInternal<FunctionComponent<    {
 name?: string;
 children?: JSXChildren;
-}>>;
+}>> | JSXNodeInternal<InternalServerComponent<SSRRevealSlotProps>>;
 
 /**
  * A ref can be either a signal or a function. Note that the type of Signal is Element so that it
@@ -3008,7 +3056,7 @@ export declare const _resolveContextWithoutSequentialScope: <STATE>(context: Con
  * const Cmp = component$(() => {
  *   const city = useSignal('');
  *
- *   const weather = useAsync$(async ({ track, cleanup, abortSignal }) => {
+ *   const weather = useComputed$(async ({ track, cleanup, abortSignal }) => {
  *     const cityName = track(city);
  *     const res = await fetch(`http://weatherdata.com?city=${cityName}`, {
  *       signal: abortSignal,
@@ -3022,7 +3070,7 @@ export declare const _resolveContextWithoutSequentialScope: <STATE>(context: Con
  *       <input name="city" bind:value={city} />
  *       <div>
  *         Temperature:{' '}
- *         {weather.loading
+ *         {weather.pending
  *           ? 'Loading...'
  *           : weather.error
  *             ? `Error: ${weather.error.message}`
@@ -3033,8 +3081,8 @@ export declare const _resolveContextWithoutSequentialScope: <STATE>(context: Con
  * });
  * ```
  *
- * @deprecated Use `useAsync$` instead, which is more efficient, and has a more flexible API. Just
- *   read the `loading` and `error` properties from the returned signal to determine the status.
+ * @deprecated Use `useComputed$` instead. Read the `pending` and `error` properties from the
+ *   returned signal to determine the status.
  * @public
  */
 export declare const Resource: <T>({ value, onResolved, onPending, onRejected, }: ResourceProps<T>) => JSXOutput;
@@ -3095,7 +3143,7 @@ declare interface ResourceReturnInternal<T> {
 }
 
 /** @internal */
-export declare const _restProps: (props: PropsProxy, omit?: string[], target?: Props) => Props;
+export declare const _restProps: (props: unknown, omit?: string[], target?: Props) => Props;
 
 /** @internal */
 export declare const _reT: ({ cleanup }: TaskCtx) => void;
@@ -3399,7 +3447,7 @@ export declare abstract class _SharedContainer implements _Container {
     } | null, symbolToChunkResolver: SymbolToChunkResolver, writer?: StreamWriter): SerializationContext;
     $checkPendingCount$(): void;
     abstract ensureProjectionResolved(host: _HostElement): void;
-    abstract handleError(err: any, $host$: _HostElement | null): void;
+    abstract handleError(err: any, $host$: _HostElement | null, phase?: ErrorBoundaryPhase): void;
     abstract getParentHost(host: _HostElement): _HostElement | null;
     abstract setContext<T>(host: _HostElement, context: ContextId<T>, value: T): void;
     abstract resolveContext<T>(host: _HostElement, contextId: ContextId<T>): T | undefined;
@@ -3754,9 +3802,14 @@ declare interface SSRContainer extends _Container {
     readonly symbolToChunkResolver: SymbolToChunkResolver;
     readonly resolvedManifest: ResolvedManifest;
     readonly outOfOrderStreaming: boolean;
+    readonly $transformError$: ((error: unknown) => unknown) | undefined;
     additionalHeadNodes: Array<JSXNodeInternal>;
     additionalBodyNodes: Array<JSXNodeInternal>;
     $noScriptHere$: number;
+    /** Innermost open ErrorBoundary content host, so the walker can skip an errored subtree. */
+    $errorContentHost$: ISsrNode | null;
+    /** Set when an ErrorBoundary caught during this container's render. */
+    $hasBoundaryError$?: boolean;
     /**
      * Lets the container place a root-level `useOn` placeholder `<script>` itself when injecting it
      * inline would put it at an illegal position. Returns `true` if the container took the node, in
@@ -3786,11 +3839,15 @@ declare interface SSRContainer extends _Container {
     render(jsx: JSXOutput): Promise<void>;
     renderJSX(jsx: JSXOutput, options: SSRRenderJSXOptions): Promise<void>;
     $runQueuedRender$<T>(render: () => ValueOrPromise<T>): ValueOrPromise<T>;
-    nextOutOfOrderId(): number;
+    nextOutOfOrderId(markUsed?: boolean): number;
     emitOutOfOrderSegmentScripts(scripts: string): void;
     segment(segmentId: string, jsx: JSXOutput, options: SSRRenderJSXOptions): Promise<SSROutOfOrderSegment>;
     queueOutOfOrderSegment(segment: Promise<void>): void;
     emitOutOfOrderExecutorIfNeeded(): void;
+    emitErrorSwapExecutorIfNeeded(): void;
+    $registerErrorSwap$(boundaryId: number): void;
+    /** Keeps the node re-renderable after resume. */
+    $retainForResume$(node: ISsrNode | null | undefined): void;
     emitInlineScript(script: string): void;
     writeScript(attrs: Props, body?: string): void;
     emitPreloaderPre(): void;
@@ -3847,6 +3904,7 @@ declare interface SSRRootRefPathChunk {
 
 declare interface SSRSegmentContainer extends SSRContainer {
     $rootContainer$: SSRContainer;
+    $errorSwapIds$: number[] | null;
     $recordExternalRootEffect$(producer: unknown, effect: EffectSubscription, prop: string | symbol | null, sourceEffects?: Map<string | symbol, Set<EffectSubscription>>): void;
     $finalizeOutOfOrderSegment$(segmentId: string, segment: SSROutOfOrderSegment): Promise<{
         html: string;
@@ -3893,7 +3951,7 @@ declare type SSRWriteChunk = string | number | SSRRootRefPathChunk | SSRRootRefD
 
 declare type StackFn = () => ValueOrPromise<void>;
 
-declare type StackValue = ValueOrPromise<JSXOutput | StackFn | Promise<JSXOutput> | typeof Promise | AsyncGenerator | typeof MaybeAsyncSignal>;
+declare type StackValue = ValueOrPromise<JSXOutput | StackFn | Promise<JSXOutput> | typeof Promise | AsyncGenerator | typeof MaybeAsyncSignal | typeof InvokeJSXFunction>;
 
 declare type StopPropagation = {
     [K in keyof HTMLElementEventMap as `stoppropagation:${K}`]?: boolean;
@@ -4428,37 +4486,6 @@ export declare const unwrapStore: <T>(value: T) => T;
  */
 export declare function _updateProjectionProps(container: _Container, vnode: _VirtualVNode, newProps: Record<string, unknown>): void;
 
-/**
- * Creates an AsyncSignal which 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.
- *
- * @deprecated Use `useComputed$` instead, it has async support now. It auto-tracks synchronous
- *   reads; after the first `await`, use the provided `track()` like before.
- * @public
- */
-export declare const useAsync$: <T>(qrl: AsyncFn<T>, options?: AsyncSignalOptions<T> | undefined) => AsyncSignal<T>;
-
-/**
- * @deprecated Use `useComputed$` instead, it has async support now.
- * @internal
- */
-export declare const useAsyncQrl: <T>(qrl: QRL<AsyncFn<T>>, options?: AsyncSignalOptions<T>) => AsyncSignal<T>;
-
 /**
  * Creates a computed signal which is calculated from the given function. A computed signal is a
  * signal which is calculated from other signals. When the signals change, the computed signal is
@@ -4609,9 +4636,6 @@ export declare const useContext: UseContext;
  */
 export declare const useContextProvider: <STATE>(context: ContextId<STATE>, newValue: STATE) => void;
 
-/** @public */
-export declare const useErrorBoundary: () => ErrorBoundaryStore;
-
 /**
  * Injected by the optimizer into component$ bodies in HMR mode. Registers a document event listener
  * that triggers component re-render on HMR updates.
@@ -5117,7 +5141,7 @@ export declare const _VAR_PROPS: unique symbol;
 export declare const _verifySerializable: <T>(value: T, preMessage?: string) => T;
 
 /**
- * 2.0.0-beta.40-dev+a459d55
+ * 2.0.0-beta.42-dev+3473a49
  *
  * @public
  */
@@ -5235,7 +5259,8 @@ declare const enum VNodeDataFlag {
     VIRTUAL_NODE = 2,
     ELEMENT_NODE = 4,
     REFERENCE = 8,
-    SERIALIZE = 16
+    SERIALIZE = 16,
+    INERT = 32
 }
 
 /**