@ai0x0/utils 0.0.37 → 0.0.38

package/lib/backend/sqlite/actions/get-list-query.js

@@ -0,0 +1,165 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc2) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc2 = __getOwnPropDesc(from, key)) || desc2.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/backend/sqlite/actions/get-list-query.ts
+var get_list_query_exports = {};
+__export(get_list_query_exports, {
+  getListQuery: () => getListQuery
+});
+module.exports = __toCommonJS(get_list_query_exports);
+var import_drizzle_orm = require("drizzle-orm");
+function getListQuery({
+  db,
+  fields,
+  jsonArrayFields,
+  params,
+  relations,
+  table
+}) {
+  const {
+    page = 1,
+    pageSize = 10,
+    orderBy = "createdAt",
+    orderDir = "desc",
+    ...filters
+  } = params;
+  function buildBaseQuery(table2, fields2, relations2) {
+    let queryFields = { ...fields2 };
+    if (relations2 == null ? void 0 : relations2.length) {
+      for (const { select } of relations2) {
+        queryFields = { ...queryFields, ...select };
+      }
+    }
+    const query2 = db.select(queryFields).from(table2);
+    if (relations2 == null ? void 0 : relations2.length) {
+      query2.groupBy(
+        table2.id,
+        ...relations2.filter(({ groupBy }) => groupBy).filter(({ table: table3 }) => table3).map(({ table: table3 }) => table3.id)
+      );
+    }
+    return query2;
+  }
+  function findTargetColumn(key, table2, relations2) {
+    var _a;
+    return (_a = [table2].concat(
+      (relations2 == null ? void 0 : relations2.filter(({ table: table3 }) => table3).map(({ table: table3 }) => table3)) || []
+    ).find((table3) => table3[key])) == null ? void 0 : _a[key];
+  }
+  function addCondition(conditions2, key, value, targetColumn) {
+    const isIdField = /id/i.test(key);
+    const isJsonArray = jsonArrayFields == null ? void 0 : jsonArrayFields.includes(key);
+    if (typeof value === "string") {
+      if (value.includes(",")) {
+        const values = value.split(",").map((val) => val.trim()).filter(Boolean);
+        if (values.length > 0) {
+          if (isJsonArray) {
+            conditions2.push(
+              import_drizzle_orm.sql`
+                EXISTS (
+                  SELECT 1 FROM json_each(${targetColumn}) tag
+                  WHERE tag.value LIKE ${`%${values[0]}%`}
+                )
+              `
+            );
+          } else if (isIdField) {
+            conditions2.push((0, import_drizzle_orm.inArray)(targetColumn, values));
+          } else {
+            conditions2.push(
+              (0, import_drizzle_orm.or)(
+                ...values.map((val) => (0, import_drizzle_orm.like)(targetColumn, `%${val}%`))
+              )
+            );
+          }
+        }
+      } else {
+        if (isJsonArray) {
+          conditions2.push(
+            import_drizzle_orm.sql`
+              EXISTS (
+                SELECT 1 FROM json_each(${targetColumn}) tag
+                WHERE tag.value LIKE ${`%${value}%`}
+              )
+            `
+          );
+        } else if (isIdField) {
+          conditions2.push((0, import_drizzle_orm.eq)(targetColumn, value));
+        } else {
+          conditions2.push((0, import_drizzle_orm.like)(targetColumn, `%${value}%`));
+        }
+      }
+    } else {
+      conditions2.push((0, import_drizzle_orm.eq)(targetColumn, value));
+    }
+  }
+  function buildConditions(filters2, table2, relations2) {
+    const conditions2 = [];
+    for (const [key, value] of Object.entries(filters2)) {
+      if (!value) {
+        continue;
+      }
+      if (key.endsWith("AtFrom") || key.endsWith("AtTo")) {
+        const baseFieldName = key.replace(/(AtFrom|AtTo)$/, "");
+        const targetColumn2 = findTargetColumn(
+          `${baseFieldName}At`,
+          table2,
+          relations2
+        );
+        if (!targetColumn2) {
+          continue;
+        }
+        if (key.endsWith("AtFrom")) {
+          conditions2.push((0, import_drizzle_orm.gte)(targetColumn2, new Date(value)));
+        } else if (key.endsWith("AtTo")) {
+          conditions2.push((0, import_drizzle_orm.lte)(targetColumn2, new Date(value)));
+        }
+        continue;
+      }
+      const targetColumn = findTargetColumn(
+        key,
+        table2,
+        relations2
+      );
+      if (!targetColumn) {
+        continue;
+      }
+      addCondition(conditions2, key, value, targetColumn);
+    }
+    return conditions2;
+  }
+  function buildOrderBy(table2, orderBy2, orderDir2) {
+    const orderColumn = table2[orderBy2];
+    return orderDir2 === "asc" ? (0, import_drizzle_orm.asc)(orderColumn) : (0, import_drizzle_orm.desc)(orderColumn);
+  }
+  const baseQuery = buildBaseQuery(table, fields, relations);
+  const conditions = buildConditions(filters, table, relations);
+  const query = baseQuery.where(conditions.length > 0 ? (0, import_drizzle_orm.and)(...conditions) : void 0).orderBy(buildOrderBy(table, orderBy, orderDir)).limit(pageSize).offset((page - 1) * pageSize);
+  const countQuery = db.select({ count: import_drizzle_orm.sql`COUNT(DISTINCT ${table.id})` }).from(table).where(conditions.length > 0 ? (0, import_drizzle_orm.and)(...conditions) : void 0);
+  if (relations == null ? void 0 : relations.length) {
+    for (const { table: relationTable, sql: joinSql } of relations) {
+      if (relationTable) {
+        query.leftJoin(relationTable, joinSql);
+        countQuery.leftJoin(relationTable, joinSql);
+      }
+    }
+  }
+  return { countQuery, query };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getListQuery
+});

package/lib/backend/sqlite/actions/index.d.ts

@@ -0,0 +1,6 @@
+export { createDeleteAction } from "./create-delete-action.js";
+export { createGetAction } from "./create-get-action.js";
+export { createGetListAction } from "./create-get-list-action.js";
+export { createPostAction } from "./create-post-action.js";
+export { createPutAction } from "./create-put-action.js";
+export { getListQuery } from "./get-list-query.js";

package/lib/backend/sqlite/actions/index.js

@@ -0,0 +1,44 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/backend/sqlite/actions/index.ts
+var actions_exports = {};
+__export(actions_exports, {
+  createDeleteAction: () => import_create_delete_action.createDeleteAction,
+  createGetAction: () => import_create_get_action.createGetAction,
+  createGetListAction: () => import_create_get_list_action.createGetListAction,
+  createPostAction: () => import_create_post_action.createPostAction,
+  createPutAction: () => import_create_put_action.createPutAction,
+  getListQuery: () => import_get_list_query.getListQuery
+});
+module.exports = __toCommonJS(actions_exports);
+var import_create_delete_action = require("./create-delete-action");
+var import_create_get_action = require("./create-get-action");
+var import_create_get_list_action = require("./create-get-list-action");
+var import_create_post_action = require("./create-post-action");
+var import_create_put_action = require("./create-put-action");
+var import_get_list_query = require("./get-list-query");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createDeleteAction,
+  createGetAction,
+  createGetListAction,
+  createPostAction,
+  createPutAction,
+  getListQuery
+});

package/lib/backend/sqlite/actions/transform-body.d.ts

@@ -0,0 +1 @@
+export declare const transformBody: <T extends Record<string, unknown>>(body: T) => T;

package/lib/backend/sqlite/actions/transform-body.js

@@ -0,0 +1,49 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/backend/sqlite/actions/transform-body.ts
+var transform_body_exports = {};
+__export(transform_body_exports, {
+  transformBody: () => transformBody
+});
+module.exports = __toCommonJS(transform_body_exports);
+var import_dayjs = __toESM(require("dayjs"));
+var transformBody = (body) => {
+  for (const key in body) {
+    if (key.endsWith("At")) {
+      body[key] = (0, import_dayjs.default)(
+        body[key]
+      ).toDate();
+    }
+  }
+  return body;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  transformBody
+});

package/lib/backend/sqlite/errors.d.ts

@@ -0,0 +1,4 @@
+export declare class HttpError extends Error {
+    status: number;
+    constructor(status: number, message: string);
+}

package/lib/backend/sqlite/errors.js

@@ -0,0 +1,35 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/backend/sqlite/errors.ts
+var errors_exports = {};
+__export(errors_exports, {
+  HttpError: () => HttpError
+});
+module.exports = __toCommonJS(errors_exports);
+var HttpError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.name = "HttpError";
+    this.status = status;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HttpError
+});

package/lib/backend/sqlite/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./actions/index.js";
+export * from "./route-operation/index.js";
+export * from "./schemas/index.js";
+export * from "./errors.js";
+export * from "./types.js";

package/lib/backend/sqlite/index.js

@@ -0,0 +1,31 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/backend/sqlite/index.ts
+var sqlite_exports = {};
+module.exports = __toCommonJS(sqlite_exports);
+__reExport(sqlite_exports, require("./actions"), module.exports);
+__reExport(sqlite_exports, require("./route-operation"), module.exports);
+__reExport(sqlite_exports, require("./schemas"), module.exports);
+__reExport(sqlite_exports, require("./errors"), module.exports);
+__reExport(sqlite_exports, require("./types"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./actions"),
+  ...require("./route-operation"),
+  ...require("./schemas"),
+  ...require("./errors"),
+  ...require("./types")
+});

package/lib/backend/sqlite/route-operation/delete-operation.d.ts

@@ -0,0 +1,10 @@
+import { TypedNextResponse } from "next-rest-framework";
+import { BaseTable } from "../types.js";
+export interface DeleteOperationOptions<TTable extends BaseTable> {
+    table: TTable;
+    summary?: string;
+    onSuccess?: () => Promise<void>;
+    onError?: (_error: Error) => Promise<ReturnType<(typeof TypedNextResponse)["json"]> | undefined>;
+    byCreator?: boolean;
+}
+export declare const createDeleteOperation: any;

package/lib/backend/sqlite/route-operation/delete-operation.js

@@ -0,0 +1,91 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/backend/sqlite/route-operation/delete-operation.ts
+var delete_operation_exports = {};
+__export(delete_operation_exports, {
+  createDeleteOperation: () => createDeleteOperation
+});
+module.exports = __toCommonJS(delete_operation_exports);
+var import_next_rest_framework = require("next-rest-framework");
+var import_zod = require("zod");
+var import_get_table_name = __toESM(require("./get-table-name"));
+var import_actions = require("../actions");
+var import_errors = require("../errors");
+var createDeleteOperation = ({
+  db,
+  getSession
+}) => ({
+  table,
+  summary,
+  onSuccess,
+  onError,
+  byCreator = true
+}) => (0, import_next_rest_framework.routeOperation)({
+  method: "DELETE",
+  openApiOperation: {
+    summary,
+    tags: [(0, import_get_table_name.default)(table)]
+  }
+}).input({
+  body: import_zod.z.object({
+    id: import_zod.z.string()
+  }),
+  contentType: "application/json"
+}).handler(async (req) => {
+  try {
+    const body = await req.json();
+    if (byCreator) {
+      const { userId } = await getSession(req) || {};
+      body.creatorId = userId;
+    }
+    const data = await (0, import_actions.createDeleteAction)({ table, db })(body);
+    await (onSuccess == null ? void 0 : onSuccess());
+    return import_next_rest_framework.TypedNextResponse.json(data, {
+      status: 200
+    });
+  } catch (e) {
+    if (!(e instanceof import_errors.HttpError)) {
+      console.error(e);
+    }
+    const response = await (onError == null ? void 0 : onError(e));
+    if (response) {
+      return response;
+    }
+    if (e instanceof import_errors.HttpError) {
+      return import_next_rest_framework.TypedNextResponse.json({ message: e.message }, {
+        status: e.status
+      });
+    }
+    throw e;
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createDeleteOperation
+});

package/lib/backend/sqlite/route-operation/get-list-operation.d.ts

@@ -0,0 +1,22 @@
+import { z, ZodSchema } from "zod";
+import { TypedNextRequest, TypedNextResponse } from "next-rest-framework";
+import { BaseTable, GetListRelations } from "../types.js";
+export interface GetListOperationOptions<T extends ZodSchema, Q extends ZodSchema, TTable extends BaseTable> {
+    bodySchema: T;
+    jsonArrayFields?: string[];
+    querySchema: Q;
+    relations?: GetListRelations;
+    setParams?: (_req: TypedNextRequest<"GET", "application/json", unknown, z.infer<Q>>) => Promise<Record<string, unknown>>;
+    byCreator?: boolean;
+    summary?: string;
+    table: TTable;
+    onSuccess?: <D extends T>(_data: {
+        data: z.infer<D>[];
+        total: number;
+    }) => Promise<{
+        data: z.infer<T>[];
+        total: number;
+    }>;
+    onError?: (_error: Error) => Promise<ReturnType<(typeof TypedNextResponse)["json"]> | undefined>;
+}
+export declare const createGetListOperation: any;

package/lib/backend/sqlite/route-operation/get-list-operation.js

@@ -0,0 +1,108 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/backend/sqlite/route-operation/get-list-operation.ts
+var get_list_operation_exports = {};
+__export(get_list_operation_exports, {
+  createGetListOperation: () => createGetListOperation
+});
+module.exports = __toCommonJS(get_list_operation_exports);
+var import_next_rest_framework = require("next-rest-framework");
+var import_get_table_name = __toESM(require("./get-table-name"));
+var import_schemas = require("../schemas");
+var import_actions = require("../actions");
+var createGetListOperation = ({
+  db,
+  getSession
+}) => ({
+  querySchema,
+  bodySchema,
+  table,
+  summary,
+  relations,
+  jsonArrayFields,
+  setParams,
+  onSuccess,
+  onError,
+  byCreator = true
+}) => (0, import_next_rest_framework.routeOperation)({
+  method: "GET",
+  openApiOperation: {
+    summary,
+    tags: [(0, import_get_table_name.default)(table)]
+  }
+}).input({
+  query: querySchema
+}).outputs([
+  {
+    body: (0, import_schemas.listBodySchema)(bodySchema),
+    contentType: "application/json",
+    status: 200
+  }
+]).handler(async (req) => {
+  try {
+    const params = await (setParams == null ? void 0 : setParams(
+      req
+    )) || {};
+    if (byCreator) {
+      const { userId } = await getSession(req) || {};
+      params.creatorId = userId;
+    }
+    let result = await (0, import_actions.createGetListAction)({
+      bodySchema,
+      db,
+      jsonArrayFields,
+      relations,
+      table
+    })(
+      Object.assign(
+        Object.fromEntries(new URL(req.url).searchParams),
+        params
+      )
+    );
+    if (onSuccess) {
+      result = await onSuccess(result);
+    }
+    return import_next_rest_framework.TypedNextResponse.json(
+      result,
+      { status: 200 }
+    );
+  } catch (e) {
+    console.error(e);
+    const response = await (onError == null ? void 0 : onError(e));
+    if (response) {
+      return response;
+    } else {
+      throw e;
+    }
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createGetListOperation
+});

package/lib/backend/sqlite/route-operation/get-operation.d.ts

@@ -0,0 +1,16 @@
+import { z, ZodSchema } from "zod";
+import { TypedNextRequest, TypedNextResponse } from "next-rest-framework";
+import { BaseTable, GetListRelations } from "../types.js";
+export interface GetOperationOptions<T extends ZodSchema, Q extends ZodSchema, TTable extends BaseTable> {
+    bodySchema: T;
+    jsonArrayFields?: string[];
+    querySchema: Q;
+    relations?: GetListRelations;
+    setParams?: (_req: TypedNextRequest<"GET", "application/json", unknown, z.infer<Q>>) => Promise<Record<string, unknown>>;
+    onSuccess?: (_data: z.infer<T>) => Promise<z.infer<T>>;
+    onError?: (_error: Error) => Promise<ReturnType<(typeof TypedNextResponse)["json"]> | undefined>;
+    summary?: string;
+    table: TTable;
+    byCreator?: boolean;
+}
+export declare const createGetOperation: any;