@angular/core 22.0.0-next.1 → 22.0.0-next.11

package/third_party/@mcp-b/webmcp-types/dist/json-schema.d.ts

@@ -0,0 +1,196 @@
+import type { JsonPrimitive, JsonValue } from './common.js';
+/**
+ * Primitive JSON Schema `type` values supported by the MVP inference layer.
+ */
+export type JsonSchemaPrimitiveType = 'string' | 'number' | 'integer' | 'boolean' | 'null';
+/**
+ * JSON Schema `type` values supported by the MVP inference layer.
+ */
+export type JsonSchemaType = JsonSchemaPrimitiveType | 'object' | 'array';
+/**
+ * JSON Schema multi-type tuple (for example `["string", "null"]`).
+ */
+export type JsonSchemaTypeArray = readonly [JsonSchemaType, ...JsonSchemaType[]];
+/**
+ * Literal values supported in JSON Schema `enum`/`const`.
+ */
+export type JsonSchemaEnumValue = JsonPrimitive | JsonValue;
+/**
+ * Extra JSON Schema keywords tolerated by the inference layer.
+ *
+ * These keys are intentionally accepted as opaque metadata. Inference only uses
+ * the core MVP keywords and ignores these fields.
+ */
+interface SupplementalJsonSchemaKeywords {
+    $defs?: unknown;
+    $ref?: unknown;
+    additionalItems?: unknown;
+    allOf?: unknown;
+    anyOf?: unknown;
+    contains?: unknown;
+    definitions?: unknown;
+    dependentRequired?: unknown;
+    dependentSchemas?: unknown;
+    format?: unknown;
+    if?: unknown;
+    maxContains?: unknown;
+    minContains?: unknown;
+    not?: unknown;
+    oneOf?: unknown;
+    patternProperties?: unknown;
+    prefixItems?: unknown;
+    propertyNames?: unknown;
+    then?: unknown;
+    unevaluatedItems?: unknown;
+    unevaluatedProperties?: unknown;
+}
+/**
+ * Non-validation metadata accepted by the MVP inference subset.
+ */
+interface JsonSchemaMetadata extends SupplementalJsonSchemaKeywords {
+    default?: JsonValue;
+    description?: string;
+    examples?: readonly JsonValue[];
+    /**
+     * OpenAPI-compatible nullability marker.
+     */
+    nullable?: boolean;
+    title?: string;
+}
+/**
+ * JSON Schema for `type: "string"`.
+ */
+export interface JsonSchemaString extends JsonSchemaMetadata {
+    const?: string;
+    enum?: readonly string[];
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+    type: 'string';
+}
+/**
+ * JSON Schema for `type: "number"` and `type: "integer"`.
+ */
+export interface JsonSchemaNumber extends JsonSchemaMetadata {
+    const?: number;
+    enum?: readonly number[];
+    exclusiveMaximum?: number;
+    exclusiveMinimum?: number;
+    maximum?: number;
+    minimum?: number;
+    multipleOf?: number;
+    type: 'number' | 'integer';
+}
+/**
+ * JSON Schema for `type: "boolean"`.
+ */
+export interface JsonSchemaBoolean extends JsonSchemaMetadata {
+    const?: boolean;
+    enum?: readonly boolean[];
+    type: 'boolean';
+}
+/**
+ * JSON Schema for `type: "null"`.
+ */
+export interface JsonSchemaNull extends JsonSchemaMetadata {
+    const?: null;
+    enum?: readonly null[];
+    type: 'null';
+}
+/**
+ * JSON Schema for `type: "array"`.
+ */
+export interface JsonSchemaArray extends JsonSchemaMetadata {
+    items: JsonSchemaForInference;
+    maxItems?: number;
+    minItems?: number;
+    type: 'array';
+    uniqueItems?: boolean;
+}
+/**
+ * JSON Schema for `type: "object"`.
+ */
+export interface JsonSchemaObject extends JsonSchemaMetadata {
+    additionalProperties?: boolean | JsonSchemaForInference;
+    maxProperties?: number;
+    minProperties?: number;
+    properties?: Readonly<Record<string, JsonSchemaForInference>>;
+    required?: readonly string[];
+    type: 'object';
+}
+/**
+ * JSON Schema for multi-type unions via `type: [...]`.
+ */
+export interface JsonSchemaMultiType extends JsonSchemaMetadata {
+    additionalProperties?: boolean | JsonSchemaForInference;
+    const?: JsonSchemaEnumValue;
+    enum?: readonly JsonSchemaEnumValue[];
+    items?: JsonSchemaForInference;
+    properties?: Readonly<Record<string, JsonSchemaForInference>>;
+    required?: readonly string[];
+    type: JsonSchemaTypeArray;
+}
+/**
+ * JSON Schema subset supported by the MVP type inference layer.
+ */
+export type JsonSchemaForInference = JsonSchemaArray | JsonSchemaBoolean | JsonSchemaMultiType | JsonSchemaNull | JsonSchemaNumber | JsonSchemaObject | JsonSchemaString;
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type EmptyObject = Record<never, never>;
+type EnumLiteral<TSchema> = TSchema extends {
+    enum: infer TEnum extends readonly unknown[];
+} ? Extract<TEnum[number], JsonSchemaEnumValue> : never;
+type ConstLiteral<TSchema> = TSchema extends {
+    const: infer TConst;
+} ? Extract<TConst, JsonSchemaEnumValue> : never;
+type PropertiesOf<TSchema> = TSchema extends {
+    properties: infer TProperties extends Readonly<Record<string, JsonSchemaForInference>>;
+} ? TProperties : EmptyObject;
+type RequiredKeysOf<TSchema, TProperties extends Record<string, unknown>> = TSchema extends {
+    required: readonly (infer TRequired)[];
+} ? string extends TRequired ? never : Extract<TRequired, keyof TProperties & string> : never;
+type RequiredProps<TProperties extends Record<string, JsonSchemaForInference>, TRequiredKeys extends string> = {
+    [K in keyof TProperties as K extends TRequiredKeys ? K : never]-?: InferJsonSchema<TProperties[K]>;
+};
+type OptionalProps<TProperties extends Record<string, JsonSchemaForInference>, TRequiredKeys extends string> = {
+    [K in keyof TProperties as K extends TRequiredKeys ? never : K]?: InferJsonSchema<TProperties[K]>;
+};
+type PropertyKeysOf<TSchema> = keyof PropertiesOf<TSchema> & string;
+type AdditionalSchemaOf<TSchema> = TSchema extends {
+    additionalProperties: infer TAdditional;
+} ? TAdditional : undefined;
+type AdditionalPropsValue<TSchema> = AdditionalSchemaOf<TSchema> extends JsonSchemaForInference ? InferJsonSchema<AdditionalSchemaOf<TSchema>> : unknown;
+type AdditionalPropsOf<TSchema> = TSchema extends {
+    additionalProperties: false;
+} ? EmptyObject : AdditionalSchemaOf<TSchema> extends JsonSchemaForInference ? PropertyKeysOf<TSchema> extends never ? Record<string, AdditionalPropsValue<TSchema>> : Record<string, unknown> : Record<string, unknown>;
+type InferObject<TSchema> = Simplify<RequiredProps<PropertiesOf<TSchema>, RequiredKeysOf<TSchema, PropertiesOf<TSchema>>> & OptionalProps<PropertiesOf<TSchema>, RequiredKeysOf<TSchema, PropertiesOf<TSchema>>> & AdditionalPropsOf<TSchema>>;
+type TypeKeywordOf<TSchema> = TSchema extends {
+    type?: infer TType;
+} ? 'type' extends keyof TSchema ? TType : undefined : undefined;
+type TypeOptionsOf<TSchema> = [TypeKeywordOf<TSchema>] extends [undefined] ? 'object' : TypeKeywordOf<TSchema> extends readonly unknown[] ? Extract<TypeKeywordOf<TSchema>[number], JsonSchemaType> : Extract<TypeKeywordOf<TSchema>, JsonSchemaType>;
+type InferFromTypeOption<TSchema, TType extends JsonSchemaType> = TType extends 'object' ? InferObject<TSchema> : TType extends 'array' ? TSchema extends {
+    items: infer TItems;
+} ? InferJsonSchema<TItems>[] : unknown[] : TType extends 'string' ? string : TType extends 'number' | 'integer' ? number : TType extends 'boolean' ? boolean : TType extends 'null' ? null : unknown;
+type InferFromTypeKeyword<TSchema> = TypeOptionsOf<TSchema> extends never ? unknown : InferFromTypeOption<TSchema, TypeOptionsOf<TSchema>>;
+type ApplyNullable<TSchema, TValue> = TSchema extends {
+    nullable: true;
+} ? TValue | null : TValue;
+/**
+ * Infers a TypeScript type from the supported JSON Schema subset.
+ *
+ * `const` and `enum` take precedence when present.
+ */
+export type InferJsonSchema<TSchema> = [ConstLiteral<TSchema>] extends [never] ? [EnumLiteral<TSchema>] extends [never] ? ApplyNullable<TSchema, InferFromTypeKeyword<TSchema>> : ApplyNullable<TSchema, EnumLiteral<TSchema>> : ApplyNullable<TSchema, ConstLiteral<TSchema>>;
+type IsWidenedTypeKeyword<TTypeKeyword> = string extends TTypeKeyword ? true : TTypeKeyword extends readonly unknown[] ? string extends TTypeKeyword[number] ? true : false : false;
+type IncludesObjectType<TSchema> = TypeOptionsOf<TSchema> extends never ? false : 'object' extends TypeOptionsOf<TSchema> ? true : false;
+/**
+ * Infers tool argument types from a root `InputSchema`.
+ *
+ * If the schema is not a literal object schema (for example a widened
+ * `InputSchema` loaded at runtime), this intentionally falls back to
+ * `Record<string, unknown>`.
+ */
+export type InferArgsFromInputSchema<TSchema> = IsWidenedTypeKeyword<TypeKeywordOf<TSchema>> extends true ? Record<string, unknown> : IncludesObjectType<TSchema> extends true ? InferObject<TSchema> : Record<string, unknown>;
+export {};
+//# sourceMappingURL=json-schema.d.ts.map

package/third_party/@mcp-b/webmcp-types/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright Google LLC 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://angular.dev/license
+ */
+
+export {InferArgsFromInputSchema, JsonSchemaForInference} from './dist/json-schema.js';

package/types/_api-chunk.d.ts

@@ -1,10 +1,10 @@
 /**
- * @license Angular v22.0.0-next.1
+ * @license Angular v22.0.0-next.11
  * (c) 2010-2026 Google LLC. https://angular.dev/
  * License: MIT
  */
 
-import { OutputRef, OutputRefSubscription, DestroyRef, Signal, WritableSignal, ValueEqualityFn, Injector } from './_chrome_dev_tools_performance-chunk.js';
+import { OutputRef, OutputRefSubscription, DestroyRef, Signal, ValueEqualityFn, Injector, WritableSignal } from './_chrome_dev_tools_performance-chunk.js';
 
 /**
  * An `OutputEmitterRef` is created by the `output()` function and can be
@@ -138,7 +138,7 @@ interface ResourceParamsContext {
  *
  * `local` - The resource's value was set locally via `.set()` or `.update()`.
  *
- * @experimental
+ * @publicApi 22.0
  */
 type ResourceStatus = 'idle' | 'error' | 'loading' | 'reloading' | 'resolved' | 'local';
 /**
@@ -148,7 +148,7 @@ type ResourceStatus = 'idle' | 'error' | 'loading' | 'reloading' | 'resolved' |
  * The usual way of creating a `Resource` is through the `resource` function, but various other APIs
  * may present `Resource` instances to describe their own concepts.
  *
- * @experimental
+ * @publicApi 22.0
  */
 interface Resource<T> {
     /**
@@ -185,7 +185,7 @@ interface Resource<T> {
  *
  * Overwriting the value of a resource sets it to the 'local' state.
  *
- * @experimental
+ * @publicApi 22.0
  */
 interface WritableResource<T> extends Resource<T> {
     readonly value: WritableSignal<T>;
@@ -213,7 +213,7 @@ interface WritableResource<T> extends Resource<T> {
 /**
  * A `WritableResource` created through the `resource` function.
  *
- * @experimental
+ * @publicApi 22.0
  */
 interface ResourceRef<T> extends WritableResource<T> {
     hasValue(this: T extends undefined ? this : never): this is ResourceRef<Exclude<T, undefined>>;
@@ -227,7 +227,7 @@ interface ResourceRef<T> extends WritableResource<T> {
  * Parameter to a `ResourceLoader` which gives the request and other options for the current loading
  * operation.
  *
- * @experimental
+ * @publicApi 22.0
  */
 interface ResourceLoaderParams<R> {
     params: NoInfer<Exclude<R, undefined>>;
@@ -239,19 +239,19 @@ interface ResourceLoaderParams<R> {
 /**
  * Loading function for a `Resource`.
  *
- * @experimental
+ * @publicApi 22.0
  */
 type ResourceLoader<T, R> = (param: ResourceLoaderParams<R>) => PromiseLike<T>;
 /**
  * Streaming loader for a `Resource`.
  *
- * @experimental
+ * @publicApi 22.0
  */
-type ResourceStreamingLoader<T, R> = (param: ResourceLoaderParams<R>) => PromiseLike<Signal<ResourceStreamItem<T>>>;
+type ResourceStreamingLoader<T, R> = (param: ResourceLoaderParams<R>) => Signal<ResourceStreamItem<T>> | PromiseLike<Signal<ResourceStreamItem<T>>> | undefined;
 /**
  * Options to the `resource` function, for creating a resource.
  *
- * @experimental
+ * @publicApi 22.0
  */
 interface BaseResourceOptions<T, R> {
     /**
@@ -274,11 +274,16 @@ interface BaseResourceOptions<T, R> {
      * Overrides the `Injector` used by `resource`.
      */
     injector?: Injector;
+    /**
+     * Identifier used to cache the resource data in the `TransferState` during server-side rendering and to retrieve it on the client side.
+     * This value value needs to be identical for both the client and server.
+     */
+    id?: string;
 }
 /**
  * Options to the `resource` function, for creating a resource.
  *
- * @experimental
+ * @publicApi 22.0
  */
 interface PromiseResourceOptions<T, R> extends BaseResourceOptions<T, R> {
     /**
@@ -293,7 +298,7 @@ interface PromiseResourceOptions<T, R> extends BaseResourceOptions<T, R> {
 /**
  * Options to the `resource` function, for creating a resource.
  *
- * @experimental
+ * @publicApi 22.0
  */
 interface StreamingResourceOptions<T, R> extends BaseResourceOptions<T, R> {
     /**
@@ -307,7 +312,7 @@ interface StreamingResourceOptions<T, R> extends BaseResourceOptions<T, R> {
     loader?: never;
 }
 /**
- * @experimental
+ * @publicApi 22.0
  */
 type ResourceOptions<T, R> = (PromiseResourceOptions<T, R> | StreamingResourceOptions<T, R>) & {
     /**
@@ -316,7 +321,7 @@ type ResourceOptions<T, R> = (PromiseResourceOptions<T, R> | StreamingResourceOp
     debugName?: string;
 };
 /**
- * @experimental
+ * @publicApi 22.0
  */
 type ResourceStreamItem<T> = {
     value: T;
@@ -326,7 +331,7 @@ type ResourceStreamItem<T> = {
 /**
  * An explicit representation of a resource's state.
  *
- * @experimental
+ * @publicApi 22.0
  * @see [Resource composition with snapshots](guide/signals/resource#resource-composition-with-snapshots)
  */
 type ResourceSnapshot<T> = {
@@ -342,6 +347,28 @@ type ResourceSnapshot<T> = {
     readonly status: 'error';
     readonly error: Error;
 };
+/**
+ * Options for `debounced`.
+ *
+ * @see [Debouncing signals with `debounced`](guide/signals/debounced)
+ *
+ * @experimental 22.0
+ */
+interface DebouncedOptions<T> {
+    /** The `Injector` to use for the debounced resource. */
+    injector?: Injector;
+    /** The equality function to use for comparing values. */
+    equal?: ValueEqualityFn<T>;
+}
+/**
+ * Represents the wait condition for item debouncing.
+ * Can be a number of milliseconds or a function that returns a Promise.
+ *
+ * @see [Debouncing signals with `debounced`](guide/signals/debounced)
+ *
+ * @experimental 22.0
+ */
+type DebounceTimer<T> = number | ((value: T, lastValue: ResourceSnapshot<T>) => Promise<void> | void);
 
 export { OutputEmitterRef, ResourceDependencyError, ResourceParamsStatus, getOutputDestroyRef, output };
-export type { BaseResourceOptions, OutputOptions, PromiseResourceOptions, Resource, ResourceLoader, ResourceLoaderParams, ResourceOptions, ResourceParamsContext, ResourceRef, ResourceSnapshot, ResourceStatus, ResourceStreamItem, ResourceStreamingLoader, StreamingResourceOptions, WritableResource };
+export type { BaseResourceOptions, DebounceTimer, DebouncedOptions, OutputOptions, PromiseResourceOptions, Resource, ResourceLoader, ResourceLoaderParams, ResourceOptions, ResourceParamsContext, ResourceRef, ResourceSnapshot, ResourceStatus, ResourceStreamItem, ResourceStreamingLoader, StreamingResourceOptions, WritableResource };

package/types/_chrome_dev_tools_performance-chunk.d.ts

@@ -1,10 +1,11 @@
 /**
- * @license Angular v22.0.0-next.1
+ * @license Angular v22.0.0-next.11
  * (c) 2010-2026 Google LLC. https://angular.dev/
  * License: MIT
  */
 
 import { SIGNAL } from './_formatter-chunk.js';
+import * as _angular_core from '@angular/core';
 import { EventContract } from './_event_dispatcher-chunk.js';
 
 /** Symbol used distinguish `WritableSignal` from other non-writable signals and functions. */
@@ -741,7 +742,7 @@ declare abstract class Injector {
         name?: string;
     }): DestroyableInjector;
     /** @nocollapse */
-    static ɵprov: unknown;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<Injector>;
 }
 /**
  * An Injector that the owner can destroy and trigger the DestroyRef.destroy hooks.
@@ -843,7 +844,7 @@ type TimeStampName = string;
 type DevToolsColor = 'primary' | 'primary-light' | 'primary-dark' | 'secondary' | 'secondary-light' | 'secondary-dark' | 'tertiary' | 'tertiary-light' | 'tertiary-dark' | 'error';
 declare global {
     interface Console {
-        timeStamp(label: string, start: TimeStampName, end?: TimeStampName, trackName?: string, trackGroup?: string, color?: DevToolsColor): void;
+        timeStamp(label: string, start: TimeStampName, end?: TimeStampName, trackName?: string, trackGroup?: string, color?: DevToolsColor, detail?: object): void;
     }
 }
 /**