@typia/utils 12.0.0-dev.20260225

package/src/validators/LlmTypeChecker.ts

@@ -0,0 +1,402 @@
+import { ILlmSchema } from "@typia/interface";
+
+import { MapUtil } from "../utils/MapUtil";
+import { OpenApiTypeCheckerBase } from "../utils/internal/OpenApiTypeCheckerBase";
+
+/**
+ * Type checker for LLM function calling schema.
+ *
+ * `LlmTypeChecker` is a type checker of {@link ILlmSchema}, the type schema for
+ * LLM (Large Language Model) function calling.
+ *
+ * This checker provides type guard functions for validating schema types, and
+ * operators for traversing and comparing schemas.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export namespace LlmTypeChecker {
+  /* -----------------------------------------------------------
+    TYPE CHECKERS
+  ----------------------------------------------------------- */
+  /**
+   * Test whether the schema is a null type.
+   *
+   * @param schema Target schema
+   * @returns Whether null type or not
+   */
+  export const isNull = (schema: ILlmSchema): schema is ILlmSchema.INull =>
+    (schema as ILlmSchema.INull).type === "null";
+
+  /**
+   * Test whether the schema is an unknown type.
+   *
+   * @param schema Target schema
+   * @returns Whether unknown type or not
+   */
+  export const isUnknown = (
+    schema: ILlmSchema,
+  ): schema is ILlmSchema.IUnknown =>
+    (schema as ILlmSchema.IUnknown).type === undefined &&
+    !isAnyOf(schema) &&
+    !isReference(schema);
+
+  /**
+   * Test whether the schema is a boolean type.
+   *
+   * @param schema Target schema
+   * @returns Whether boolean type or not
+   */
+  export const isBoolean = (
+    schema: ILlmSchema,
+  ): schema is ILlmSchema.IBoolean =>
+    (schema as ILlmSchema.IBoolean).type === "boolean";
+
+  /**
+   * Test whether the schema is an integer type.
+   *
+   * @param schema Target schema
+   * @returns Whether integer type or not
+   */
+  export const isInteger = (
+    schema: ILlmSchema,
+  ): schema is ILlmSchema.IInteger =>
+    (schema as ILlmSchema.IInteger).type === "integer";
+
+  /**
+   * Test whether the schema is a number type.
+   *
+   * @param schema Target schema
+   * @returns Whether number type or not
+   */
+  export const isNumber = (schema: ILlmSchema): schema is ILlmSchema.INumber =>
+    (schema as ILlmSchema.INumber).type === "number";
+
+  /**
+   * Test whether the schema is a string type.
+   *
+   * @param schema Target schema
+   * @returns Whether string type or not
+   */
+  export const isString = (schema: ILlmSchema): schema is ILlmSchema.IString =>
+    (schema as ILlmSchema.IString).type === "string";
+
+  /**
+   * Test whether the schema is an array type.
+   *
+   * @param schema Target schema
+   * @returns Whether array type or not
+   */
+  export const isArray = (schema: ILlmSchema): schema is ILlmSchema.IArray =>
+    (schema as ILlmSchema.IArray).type === "array" &&
+    (schema as ILlmSchema.IArray).items !== undefined;
+
+  /**
+   * Test whether the schema is an object type.
+   *
+   * @param schema Target schema
+   * @returns Whether object type or not
+   */
+  export const isObject = (schema: ILlmSchema): schema is ILlmSchema.IObject =>
+    (schema as ILlmSchema.IObject).type === "object";
+
+  /**
+   * Test whether the schema is a reference type.
+   *
+   * @param schema Target schema
+   * @returns Whether reference type or not
+   */
+  export const isReference = (
+    schema: ILlmSchema,
+  ): schema is ILlmSchema.IReference => (schema as any).$ref !== undefined;
+
+  /**
+   * Test whether the schema is a union type.
+   *
+   * @param schema Target schema
+   * @returns Whether union type or not
+   */
+  export const isAnyOf = (schema: ILlmSchema): schema is ILlmSchema.IAnyOf =>
+    (schema as ILlmSchema.IAnyOf).anyOf !== undefined;
+
+  /* -----------------------------------------------------------
+    OPERATORS
+  ----------------------------------------------------------- */
+  /**
+   * Visit every nested schemas.
+   *
+   * Visit every nested schemas of the target, and apply the `props.closure`
+   * function.
+   *
+   * Here is the list of occurring nested visitings:
+   *
+   * - {@link ILlmSchema.IAnyOf.anyOf}
+   * - {@link ILlmSchema.IReference}
+   * - {@link ILlmSchema.IObject.properties}
+   * - {@link ILlmSchema.IArray.items}
+   *
+   * @param props Properties for visiting
+   */
+  export const visit = (props: {
+    closure: (schema: ILlmSchema, accessor: string) => void;
+    $defs?: Record<string, ILlmSchema> | undefined;
+    schema: ILlmSchema;
+    accessor?: string;
+    refAccessor?: string;
+  }): void => {
+    const already: Set<string> = new Set();
+    const refAccessor: string = props.refAccessor ?? "$input.$defs";
+    const next = (schema: ILlmSchema, accessor: string): void => {
+      props.closure(schema, accessor);
+      if (LlmTypeChecker.isReference(schema)) {
+        const key: string = schema.$ref.split("#/$defs/").pop()!;
+        if (already.has(key) === true) return;
+        already.add(key);
+        const found: ILlmSchema | undefined = props.$defs?.[key];
+        if (found !== undefined) next(found, `${refAccessor}[${key}]`);
+      } else if (LlmTypeChecker.isAnyOf(schema))
+        schema.anyOf.forEach((s, i) => next(s, `${accessor}.anyOf[${i}]`));
+      else if (LlmTypeChecker.isObject(schema)) {
+        for (const [key, value] of Object.entries(schema.properties))
+          next(value, `${accessor}.properties[${JSON.stringify(key)}]`);
+        if (
+          typeof schema.additionalProperties === "object" &&
+          schema.additionalProperties !== null
+        )
+          next(schema.additionalProperties, `${accessor}.additionalProperties`);
+      } else if (LlmTypeChecker.isArray(schema))
+        next(schema.items, `${accessor}.items`);
+    };
+    next(props.schema, props.accessor ?? "$input.schemas");
+  };
+
+  /**
+   * Test whether the `x` schema covers the `y` schema.
+   *
+   * @param props Properties for testing
+   * @returns Whether the `x` schema covers the `y` schema
+   */
+  export const covers = (props: {
+    $defs?: Record<string, ILlmSchema> | undefined;
+    x: ILlmSchema;
+    y: ILlmSchema;
+  }): boolean =>
+    coverStation({
+      $defs: props.$defs,
+      x: props.x,
+      y: props.y,
+      visited: new Map(),
+    });
+
+  const coverStation = (p: {
+    $defs?: Record<string, ILlmSchema> | undefined;
+    visited: Map<ILlmSchema, Map<ILlmSchema, boolean>>;
+    x: ILlmSchema;
+    y: ILlmSchema;
+  }): boolean => {
+    const cache: boolean | undefined = p.visited.get(p.x)?.get(p.y);
+    if (cache !== undefined) return cache;
+
+    // FOR RECURSIVE CASE
+    const nested: Map<ILlmSchema, boolean> = MapUtil.take(
+      p.visited,
+      p.x,
+      () => new Map(),
+    );
+    nested.set(p.y, true);
+
+    // COMPUTE IT
+    const result: boolean = coverSchema(p);
+    nested.set(p.y, result);
+    return result;
+  };
+
+  const coverSchema = (p: {
+    $defs?: Record<string, ILlmSchema> | undefined;
+    visited: Map<ILlmSchema, Map<ILlmSchema, boolean>>;
+    x: ILlmSchema;
+    y: ILlmSchema;
+  }): boolean => {
+    // CHECK EQUALITY
+    if (p.x === p.y) return true;
+    else if (isReference(p.x) && isReference(p.y) && p.x.$ref === p.y.$ref)
+      return true;
+
+    // COMPARE WITH FLATTENING
+    const alpha: ILlmSchema[] = flatSchema(p.$defs, p.x);
+    const beta: ILlmSchema[] = flatSchema(p.$defs, p.y);
+    if (alpha.some((x) => isUnknown(x))) return true;
+    else if (beta.some((x) => isUnknown(x))) return false;
+    return beta.every((b) =>
+      alpha.some((a) =>
+        coverEscapedSchema({
+          $defs: p.$defs,
+          visited: p.visited,
+          x: a,
+          y: b,
+        }),
+      ),
+    );
+  };
+
+  const coverEscapedSchema = (p: {
+    $defs?: Record<string, ILlmSchema> | undefined;
+    visited: Map<ILlmSchema, Map<ILlmSchema, boolean>>;
+    x: ILlmSchema;
+    y: ILlmSchema;
+  }): boolean => {
+    // CHECK EQUALITY
+    if (p.x === p.y) return true;
+    else if (isUnknown(p.x)) return true;
+    else if (isUnknown(p.y)) return false;
+    else if (isNull(p.x)) return isNull(p.y);
+    // ATOMIC CASE
+    else if (isBoolean(p.x)) return isBoolean(p.y) && coverBoolean(p.x, p.y);
+    else if (isInteger(p.x)) return isInteger(p.y) && coverInteger(p.x, p.y);
+    else if (isNumber(p.x)) return isNumber(p.y) && coverNumber(p.x, p.y);
+    else if (isString(p.x)) return isString(p.y) && coverString(p.x, p.y);
+    // INSTANCE CASE
+    else if (isArray(p.x))
+      return (
+        isArray(p.y) &&
+        coverArray({
+          $defs: p.$defs,
+          visited: p.visited,
+          x: p.x,
+          y: p.y,
+        })
+      );
+    else if (isObject(p.x))
+      return (
+        isObject(p.y) &&
+        coverObject({
+          $defs: p.$defs,
+          visited: p.visited,
+          x: p.x,
+          y: p.y,
+        })
+      );
+    else if (isReference(p.x)) return isReference(p.y) && p.x.$ref === p.y.$ref;
+    return false;
+  };
+
+  const coverArray = (p: {
+    $defs?: Record<string, ILlmSchema> | undefined;
+    visited: Map<ILlmSchema, Map<ILlmSchema, boolean>>;
+    x: ILlmSchema.IArray;
+    y: ILlmSchema.IArray;
+  }): boolean => {
+    if (
+      !(
+        p.x.minItems === undefined ||
+        (p.y.minItems !== undefined && p.x.minItems <= p.y.minItems)
+      )
+    )
+      return false;
+    else if (
+      !(
+        p.x.maxItems === undefined ||
+        (p.y.maxItems !== undefined && p.x.maxItems >= p.y.maxItems)
+      )
+    )
+      return false;
+    return coverStation({
+      $defs: p.$defs,
+      visited: p.visited,
+      x: p.x.items,
+      y: p.y.items,
+    });
+  };
+
+  const coverObject = (p: {
+    $defs?: Record<string, ILlmSchema> | undefined;
+    visited: Map<ILlmSchema, Map<ILlmSchema, boolean>>;
+    x: ILlmSchema.IObject;
+    y: ILlmSchema.IObject;
+  }): boolean => {
+    if (!p.x.additionalProperties && !!p.y.additionalProperties) return false;
+    else if (
+      !!p.x.additionalProperties &&
+      !!p.y.additionalProperties &&
+      ((typeof p.x.additionalProperties === "object" &&
+        p.y.additionalProperties === true) ||
+        (typeof p.x.additionalProperties === "object" &&
+          typeof p.y.additionalProperties === "object" &&
+          !coverStation({
+            $defs: p.$defs,
+            visited: p.visited,
+            x: p.x.additionalProperties,
+            y: p.y.additionalProperties,
+          })))
+    )
+      return false;
+    return Object.entries(p.y.properties ?? {}).every(([key, b]) => {
+      const a: ILlmSchema | undefined = p.x.properties?.[key];
+      if (a === undefined) return false;
+      else if (
+        (p.x.required?.includes(key) ?? false) === true &&
+        (p.y.required?.includes(key) ?? false) === false
+      )
+        return false;
+      return coverStation({
+        $defs: p.$defs,
+        visited: p.visited,
+        x: a,
+        y: b,
+      });
+    });
+  };
+
+  const coverBoolean = (
+    x: ILlmSchema.IBoolean,
+    y: ILlmSchema.IBoolean,
+  ): boolean => {
+    if (!!x.enum?.length)
+      return !!y.enum?.length && y.enum.every((v) => x.enum!.includes(v));
+    return true;
+  };
+
+  const coverInteger = (
+    x: ILlmSchema.IInteger,
+    y: ILlmSchema.IInteger,
+  ): boolean => {
+    if (!!x.enum?.length)
+      return !!y.enum?.length && y.enum.every((v) => x.enum!.includes(v));
+    return OpenApiTypeCheckerBase.coverInteger(x, y);
+  };
+
+  const coverNumber = (
+    x: ILlmSchema.INumber,
+    y: ILlmSchema.IInteger | ILlmSchema.INumber,
+  ): boolean => {
+    if (!!x.enum?.length)
+      return !!y.enum?.length && y.enum.every((v) => x.enum!.includes(v));
+    return OpenApiTypeCheckerBase.coverNumber(x, y);
+  };
+
+  const coverString = (
+    x: ILlmSchema.IString,
+    y: ILlmSchema.IString,
+  ): boolean => {
+    if (!!x.enum?.length)
+      return !!y.enum?.length && y.enum.every((v) => x.enum!.includes(v));
+    return OpenApiTypeCheckerBase.coverString(x, y);
+  };
+
+  const flatSchema = (
+    $defs: Record<string, ILlmSchema> | undefined,
+    schema: ILlmSchema,
+  ): ILlmSchema[] => {
+    schema = escapeReference($defs, schema);
+    if (isAnyOf(schema))
+      return schema.anyOf.map((v) => flatSchema($defs, v)).flat();
+    return [schema];
+  };
+
+  const escapeReference = (
+    $defs: Record<string, ILlmSchema> | undefined,
+    schema: ILlmSchema,
+  ): Exclude<ILlmSchema, ILlmSchema.IReference> =>
+    isReference(schema)
+      ? escapeReference($defs, $defs![schema.$ref.replace("#/$defs/", "")]!)
+      : schema;
+}

package/src/validators/OpenApiTypeChecker.ts

@@ -0,0 +1,297 @@
+import { IJsonSchemaTransformError, IResult, OpenApi } from "@typia/interface";
+
+import { OpenApiTypeCheckerBase } from "../utils/internal/OpenApiTypeCheckerBase";
+
+/**
+ * Type checker for emended OpenAPI v3.1 JSON schemas.
+ *
+ * `OpenApiTypeChecker` provides type guard functions for
+ * {@link OpenApi.IJsonSchema} (typia's normalized OpenAPI format). Use these to
+ * narrow schema types before accessing type-specific properties.
+ *
+ * Type checkers:
+ *
+ * - Primitives: {@link isNull}, {@link isBoolean}, {@link isInteger},
+ *   {@link isNumber}, {@link isString}
+ * - Constants: {@link isConstant}
+ * - Collections: {@link isArray}, {@link isTuple}, {@link isObject}
+ * - Composition: {@link isOneOf}, {@link isReference}
+ * - Special: {@link isUnknown}
+ *
+ * Also provides schema operations:
+ *
+ * - {@link visit}: Traverse and transform schemas recursively
+ * - {@link covers}: Check if one schema subsumes another
+ * - {@link escape}: Unwrap reference schemas
+ *
+ * For other OpenAPI versions, use {@link OpenApiV3TypeChecker},
+ * {@link OpenApiV3_1TypeChecker}, or {@link SwaggerV2TypeChecker}.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export namespace OpenApiTypeChecker {
+  /* -----------------------------------------------------------
+    TYPE CHECKERS
+  ----------------------------------------------------------- */
+  /**
+   * Test whether the schema is a nul type.
+   *
+   * @param schema Target schema
+   * @returns Whether null type or not
+   */
+  export const isNull = (
+    schema: OpenApi.IJsonSchema,
+  ): schema is OpenApi.IJsonSchema.INull =>
+    OpenApiTypeCheckerBase.isNull(schema);
+
+  /**
+   * Test whether the schema is an unknown type.
+   *
+   * @param schema Target schema
+   * @returns Whether unknown type or not
+   */
+  export const isUnknown = (
+    schema: OpenApi.IJsonSchema,
+  ): schema is OpenApi.IJsonSchema.IUnknown =>
+    OpenApiTypeCheckerBase.isUnknown(schema);
+
+  /**
+   * Test whether the schema is a constant type.
+   *
+   * @param schema Target schema
+   * @returns Whether constant type or not
+   */
+  export const isConstant = (
+    schema: OpenApi.IJsonSchema,
+  ): schema is OpenApi.IJsonSchema.IConstant =>
+    OpenApiTypeCheckerBase.isConstant(schema);
+
+  /**
+   * Test whether the schema is a boolean type.
+   *
+   * @param schema Target schema
+   * @returns Whether boolean type or not
+   */
+  export const isBoolean = (
+    schema: OpenApi.IJsonSchema,
+  ): schema is OpenApi.IJsonSchema.IBoolean =>
+    OpenApiTypeCheckerBase.isBoolean(schema);
+
+  /**
+   * Test whether the schema is an integer type.
+   *
+   * @param schema Target schema
+   * @returns Whether integer type or not
+   */
+  export const isInteger = (
+    schema: OpenApi.IJsonSchema,
+  ): schema is OpenApi.IJsonSchema.IInteger =>
+    OpenApiTypeCheckerBase.isInteger(schema);
+
+  /**
+   * Test whether the schema is a number type.
+   *
+   * @param schema Target schema
+   * @returns Whether number type or not
+   */
+  export const isNumber = (
+    schema: OpenApi.IJsonSchema,
+  ): schema is OpenApi.IJsonSchema.INumber =>
+    OpenApiTypeCheckerBase.isNumber(schema);
+
+  /**
+   * Test whether the schema is a string type.
+   *
+   * @param schema Target schema
+   * @returns Whether string type or not
+   */
+  export const isString = (
+    schema: OpenApi.IJsonSchema,
+  ): schema is OpenApi.IJsonSchema.IString =>
+    OpenApiTypeCheckerBase.isString(schema);
+
+  /**
+   * Test whether the schema is an array type.
+   *
+   * @param schema Target schema
+   * @returns Whether array type or not
+   */
+  export const isArray = (
+    schema: OpenApi.IJsonSchema,
+  ): schema is OpenApi.IJsonSchema.IArray =>
+    OpenApiTypeCheckerBase.isArray(schema);
+
+  /**
+   * Test whether the schema is a tuple type.
+   *
+   * @param schema Target schema
+   * @returns Whether tuple type or not
+   */
+  export const isTuple = (
+    schema: OpenApi.IJsonSchema,
+  ): schema is OpenApi.IJsonSchema.ITuple =>
+    OpenApiTypeCheckerBase.isTuple(schema);
+
+  /**
+   * Test whether the schema is an object type.
+   *
+   * @param schema Target schema
+   * @returns Whether object type or not
+   */
+  export const isObject = (
+    schema: OpenApi.IJsonSchema,
+  ): schema is OpenApi.IJsonSchema.IObject =>
+    OpenApiTypeCheckerBase.isObject(schema);
+
+  /**
+   * Test whether the schema is a reference type.
+   *
+   * @param schema Target schema
+   * @returns Whether reference type or not
+   */
+  export const isReference = (
+    schema: OpenApi.IJsonSchema,
+  ): schema is OpenApi.IJsonSchema.IReference =>
+    OpenApiTypeCheckerBase.isReference(schema);
+
+  /**
+   * Test whether the schema is an union type.
+   *
+   * @param schema Target schema
+   * @returns Whether union type or not
+   */
+  export const isOneOf = (
+    schema: OpenApi.IJsonSchema,
+  ): schema is OpenApi.IJsonSchema.IOneOf =>
+    OpenApiTypeCheckerBase.isOneOf(schema);
+
+  /**
+   * Test whether the schema is recursive reference type.
+   *
+   * Test whether the target schema is a reference type, and test one thing more
+   * that the reference is self-recursive or not.
+   *
+   * @param props Properties for recursive reference test
+   * @returns Whether the schema is recursive reference type or not
+   */
+  export const isRecursiveReference = (props: {
+    components: OpenApi.IComponents;
+    schema: OpenApi.IJsonSchema;
+  }): boolean =>
+    OpenApiTypeCheckerBase.isRecursiveReference({
+      prefix: "#/components/schemas/",
+      components: props.components,
+      schema: props.schema,
+    });
+
+  /* -----------------------------------------------------------
+    OPERATORS
+  ----------------------------------------------------------- */
+  /**
+   * Escape from the {@link OpenApi.IJsonSchema.IReference} type.
+   *
+   * Escape from the {@link OpenApi.IJsonSchema.IReference} type, replacing the
+   * every references to the actual schemas. If the escape is successful, the
+   * returned schema never contains any {@link OpenApi.IJsonSchema.IReference}
+   * type in its structure.
+   *
+   * If the schema has a recursive reference, the recursive reference would be
+   * repeated as much as the `props.recursive` depth. If you've configured the
+   * `props.recursive` as `false` or `0`, it would be failed and return an
+   * {@link IJsonSchemaTransformError}. Also, if there's a
+   * {@link OpenApi.IJsonSchema.IReference} type which cannot find the matched
+   * type in the {@link OpenApi.IComponents.schemas}, it would also be failed and
+   * return an {@link IJsonSchemaTransformError} either.
+   *
+   * @param props Properties for escaping
+   * @returns Escaped schema, or error with reason
+   */
+  export const escape = (props: {
+    components: OpenApi.IComponents;
+    schema: OpenApi.IJsonSchema;
+    recursive: false | number;
+    accessor?: string;
+    refAccessor?: string;
+  }): IResult<OpenApi.IJsonSchema, IJsonSchemaTransformError> =>
+    OpenApiTypeCheckerBase.escape({
+      ...props,
+      prefix: "#/components/schemas/",
+      method: "OpenApiTypeChecker.method",
+    });
+
+  /**
+   * Unreference the schema.
+   *
+   * Unreference the schema, replacing the {@link OpenApi.IJsonSchema.IReference}
+   * type to the actual schema. Different with {@link escape} is, the
+   * `unreference` function does not resolve every references in the schema, but
+   * resolve only one time.
+   *
+   * If there's a {@link OpenApi.IJsonSchema.IReference} type which cannot find
+   * the matched type in the {@link OpenApi.IComponents.schemas}, and you've
+   * called this `unreference()` function with the reference, it would also be
+   * failed and return an {@link IJsonSchemaTransformError} value.
+   *
+   * @param props Properties of unreference
+   * @returns Unreferenced schema
+   */
+  export const unreference = (props: {
+    components: OpenApi.IComponents;
+    schema: OpenApi.IJsonSchema;
+    accessor?: string;
+    refAccessor?: string;
+  }): IResult<OpenApi.IJsonSchema, IJsonSchemaTransformError> =>
+    OpenApiTypeCheckerBase.unreference({
+      ...props,
+      prefix: "#/components/schemas/",
+      method: "OpenApiTypeChecker.unreference",
+    });
+
+  /**
+   * Visit every nested schemas.
+   *
+   * Visit every nested schemas of the target, and apply the `props.closure`
+   * function.
+   *
+   * Here is the list of occurring nested visitings:
+   *
+   * - {@link OpenApi.IJsonSchema.IOneOf.oneOf}
+   * - {@link OpenApi.IJsonSchema.IReference}
+   * - {@link OpenApi.IJsonSchema.IObject.properties}
+   * - {@link OpenApi.IJsonSchema.IObject.additionalProperties}
+   * - {@link OpenApi.IJsonSchema.IArray.items}
+   * - {@link OpenApi.IJsonSchema.ITuple.prefixItems}
+   * - {@link OpenApi.IJsonSchema.ITuple.additionalItems}
+   *
+   * @param props Properties for visiting
+   */
+  export const visit = (props: {
+    closure: (schema: OpenApi.IJsonSchema, accessor: string) => void;
+    components: OpenApi.IComponents;
+    schema: OpenApi.IJsonSchema;
+    accessor?: string;
+    refAccessor?: string;
+  }): void =>
+    OpenApiTypeCheckerBase.visit({
+      ...props,
+      prefix: "#/components/schemas/",
+    });
+
+  /**
+   * Test whether the `x` schema covers the `y` schema.
+   *
+   * @param props Properties for testing
+   * @returns Whether the `x` schema covers the `y` schema
+   */
+  export const covers = (props: {
+    components: OpenApi.IComponents;
+    x: OpenApi.IJsonSchema;
+    y: OpenApi.IJsonSchema;
+  }): boolean =>
+    OpenApiTypeCheckerBase.covers({
+      prefix: "#/components/schemas/",
+      components: props.components,
+      x: props.x,
+      y: props.y,
+    });
+}