@rolder/kit 3.0.0-alpha.11 → 3.0.0-alpha.112

package/dist/betterAuth/server/surrealDbAdapter/methods/update.js

@@ -0,0 +1,25 @@
+import { Table } from "surrealdb";
+import { getDb } from "../db/index.js";
+import { buildExpression, normalizeOutputRecordIds, normalizeRecordIds } from "../utils/index.js";
+const update_update = async ({ model, where, update, surrealDbProps, ...args })=>{
+    if (!where || 0 === where.length) throw new Error('Update requires a where clause');
+    const db = await getDb(surrealDbProps);
+    const normalized = normalizeRecordIds({
+        model,
+        data: update,
+        ...args
+    });
+    const table = new Table(model);
+    const expression = buildExpression({
+        model,
+        where,
+        ...args
+    });
+    const [updated] = await db.update(table).merge(normalized).where(expression).json();
+    return normalizeOutputRecordIds({
+        model,
+        data: updated ?? null,
+        ...args
+    });
+};
+export { update_update as update };

package/dist/betterAuth/server/surrealDbAdapter/methods/updateMany.d.ts

@@ -0,0 +1,2 @@
+import type { UpdateMany } from './types';
+export declare const updateMany: ({ model, where, update, surrealDbProps, ...args }: UpdateMany) => Promise<number>;

package/dist/betterAuth/server/surrealDbAdapter/methods/updateMany.js

@@ -0,0 +1,21 @@
+import { Table } from "surrealdb";
+import { getDb } from "../db/index.js";
+import { buildExpression, normalizeRecordIds } from "../utils/index.js";
+const updateMany = async ({ model, where, update, surrealDbProps, ...args })=>{
+    if (!where || 0 === where.length) throw new Error('UpdateMany requires a where clause');
+    const db = await getDb(surrealDbProps);
+    const normalized = normalizeRecordIds({
+        model,
+        data: update,
+        ...args
+    });
+    const table = new Table(model);
+    const expression = buildExpression({
+        model,
+        where,
+        ...args
+    });
+    const updated = await db.update(table).merge(normalized).where(expression).json();
+    return updated?.length ?? 0;
+};
+export { updateMany };

package/dist/betterAuth/server/surrealDbAdapter/types.d.ts

@@ -0,0 +1,2 @@
+import type { AdapterFactoryCustomizeAdapterCreator } from 'better-auth/adapters';
+export type Args = Parameters<AdapterFactoryCustomizeAdapterCreator>[0];

package/dist/betterAuth/server/surrealDbAdapter/utils/applyJoinMappings.d.ts

@@ -0,0 +1,2 @@
+import type { ApplyJoinMappings } from './types';
+export declare const applyJoinMappings: ({ row, mappings, ...args }: ApplyJoinMappings) => object | null;

package/dist/betterAuth/server/surrealDbAdapter/utils/applyJoinMappings.js

@@ -0,0 +1,31 @@
+import { normalizeOutputRecordIds } from "./normalizeOutputRecordIds.js";
+const applyJoinMappings = ({ row, mappings, ...args })=>{
+    if (!row || 0 === mappings.length) return row;
+    const normalized = {
+        ...row
+    };
+    for (const mapping of mappings){
+        if (void 0 !== normalized[mapping.modelName]) continue;
+        if (void 0 === normalized[mapping.sourceField]) continue;
+        const sourceValue = normalized[mapping.sourceField];
+        if (Array.isArray(sourceValue)) {
+            normalized[mapping.modelName] = sourceValue.map((item)=>normalizeOutputRecordIds({
+                    model: mapping.modelName,
+                    data: item,
+                    ...args
+                }));
+            continue;
+        }
+        if (sourceValue && 'object' == typeof sourceValue) {
+            normalized[mapping.modelName] = normalizeOutputRecordIds({
+                model: mapping.modelName,
+                data: sourceValue,
+                ...args
+            });
+            continue;
+        }
+        normalized[mapping.modelName] = sourceValue;
+    }
+    return normalized;
+};
+export { applyJoinMappings };

package/dist/betterAuth/server/surrealDbAdapter/utils/buildExpression.d.ts

@@ -0,0 +1,3 @@
+import { type Expr } from 'surrealdb';
+import type { BuildExpression } from './types';
+export declare const buildExpression: ({ model, where, ...args }: BuildExpression) => Expr | undefined;

package/dist/betterAuth/server/surrealDbAdapter/utils/buildExpression.js

@@ -0,0 +1,58 @@
+import { and, contains, eq, gt, gte, inside, lt, lte, or } from "surrealdb";
+import { normalizeWhereValue } from "./normalizeWhereValue.js";
+const buildExpression = ({ model, where, ...args })=>{
+    if (!where || 0 === where.length) return;
+    const opExpression = (clause)=>{
+        const field = clause.field;
+        const value = normalizeWhereValue({
+            model,
+            field,
+            value: clause.value,
+            ...args
+        });
+        const operator = clause.operator ?? 'eq';
+        switch(operator){
+            case 'ne':
+                return {
+                    toSQL: (ctx)=>`${field} != ${ctx.def(value)}`
+                };
+            case 'gt':
+                return gt(field, value);
+            case 'gte':
+                return gte(field, value);
+            case 'lt':
+                return lt(field, value);
+            case 'lte':
+                return lte(field, value);
+            case 'contains':
+                return contains(field, value);
+            case 'starts_with':
+                return {
+                    toSQL: (ctx)=>`string::starts_with(${field}, ${ctx.def(value)})`
+                };
+            case 'ends_with':
+                return {
+                    toSQL: (ctx)=>`string::ends_with(${field}, ${ctx.def(value)})`
+                };
+            case 'in':
+                return inside(field, value);
+            case 'not_in':
+                return {
+                    toSQL: (ctx)=>`${field} NOT IN ${ctx.def(value)}`
+                };
+            default:
+                return eq(field, value);
+        }
+    };
+    let expression;
+    for (const clause of where){
+        const next = opExpression(clause);
+        if (!expression) {
+            expression = next;
+            continue;
+        }
+        expression = 'OR' === clause.connector ? or(expression, next) : and(expression, next);
+    }
+    return expression;
+};
+export { buildExpression };

package/dist/betterAuth/server/surrealDbAdapter/utils/buildJoinPlan.d.ts

@@ -0,0 +1,9 @@
+import type { BuildJoinPlan } from './types';
+export declare const buildJoinPlan: ({ model, join, getDefaultModelName, }: BuildJoinPlan) => {
+    selectFields: string[];
+    fetchFields: Set<string>;
+    mappings: {
+        modelName: string;
+        sourceField: string;
+    }[];
+};

package/dist/betterAuth/server/surrealDbAdapter/utils/buildJoinPlan.js

@@ -0,0 +1,46 @@
+const buildJoinPlan = ({ model, join, getDefaultModelName })=>{
+    const joinFieldsByModel = {
+        user: {
+            account: 'accounts',
+            session: 'sessions'
+        }
+    };
+    const selectFields = [];
+    const fetchFields = new Set();
+    const mappings = [];
+    if (!join || 0 === Object.keys(join).length) return {
+        selectFields,
+        fetchFields,
+        mappings
+    };
+    for (const [joinModel, joinConfig] of Object.entries(join)){
+        const baseModelName = getDefaultModelName(model);
+        const joinModelName = getDefaultModelName(joinModel);
+        const relation = joinConfig.relation ?? 'one-to-many';
+        if ('one-to-one' === relation) {
+            const fromField = joinConfig.on.from;
+            selectFields.push(fromField);
+            fetchFields.add(fromField);
+            mappings.push({
+                modelName: joinModel,
+                sourceField: fromField
+            });
+            continue;
+        }
+        const computedField = joinFieldsByModel[baseModelName]?.[joinModelName];
+        if (computedField) {
+            selectFields.push(computedField);
+            fetchFields.add(computedField);
+            mappings.push({
+                modelName: joinModel,
+                sourceField: computedField
+            });
+        }
+    }
+    return {
+        selectFields,
+        fetchFields,
+        mappings
+    };
+};
+export { buildJoinPlan };

package/dist/betterAuth/server/surrealDbAdapter/utils/buildSelectFields.d.ts

@@ -0,0 +1 @@
+export declare const buildSelectFields: (select: string[] | undefined, mapField: (field: string) => string) => string;

package/dist/betterAuth/server/surrealDbAdapter/utils/buildSelectFields.js

@@ -0,0 +1,5 @@
+const buildSelectFields = (select, mapField)=>{
+    if (!select || 0 === select.length) return '*';
+    return select.map(mapField).join(', ');
+};
+export { buildSelectFields };

package/dist/betterAuth/server/surrealDbAdapter/utils/index.d.ts

@@ -0,0 +1,6 @@
+export * from './applyJoinMappings';
+export * from './buildExpression';
+export * from './buildJoinPlan';
+export * from './buildSelectFields';
+export * from './normalizeOutputRecordIds';
+export * from './normalizeRecordIds';

package/dist/betterAuth/server/surrealDbAdapter/utils/index.js

@@ -0,0 +1,6 @@
+export * from "./applyJoinMappings.js";
+export * from "./buildExpression.js";
+export * from "./buildJoinPlan.js";
+export * from "./buildSelectFields.js";
+export * from "./normalizeOutputRecordIds.js";
+export * from "./normalizeRecordIds.js";

package/dist/betterAuth/server/surrealDbAdapter/utils/normalizeOutputRecordIds.d.ts

@@ -0,0 +1,2 @@
+import type { NormalizeOutputRecordIds } from './types';
+export declare const normalizeOutputRecordIds: ({ model, data, getDefaultModelName, getDefaultFieldName, getFieldAttributes, }: NormalizeOutputRecordIds) => Record<string, unknown> | null;

package/dist/betterAuth/server/surrealDbAdapter/utils/normalizeOutputRecordIds.js

@@ -0,0 +1,43 @@
+import { RecordId } from "surrealdb";
+const normalizeOutputRecordIds = ({ model, data, getDefaultModelName, getDefaultFieldName, getFieldAttributes })=>{
+    if (!data) return data;
+    const normalized = {
+        ...data
+    };
+    const defaultModelName = getDefaultModelName(model);
+    const stripRecordId = (raw)=>{
+        if (raw instanceof RecordId) return stripRecordId(String(raw));
+        if ('string' != typeof raw) return raw;
+        const separatorIndex = raw.indexOf(':');
+        if (-1 === separatorIndex) return raw;
+        let id = raw.slice(separatorIndex + 1);
+        if (id.startsWith('⟨') && id.endsWith('⟩')) id = id.slice(1, -1);
+        return id;
+    };
+    for (const [field, value] of Object.entries(normalized)){
+        let defaultField;
+        try {
+            defaultField = getDefaultFieldName({
+                model: defaultModelName,
+                field
+            });
+        } catch  {
+            continue;
+        }
+        const applyStrip = (targetValue)=>{
+            if (Array.isArray(targetValue)) return targetValue.map((entry)=>stripRecordId(entry));
+            return stripRecordId(targetValue);
+        };
+        if ('id' === defaultField) {
+            normalized[field] = applyStrip(value);
+            continue;
+        }
+        const fieldAttr = getFieldAttributes({
+            model: defaultModelName,
+            field: defaultField
+        });
+        if (fieldAttr?.references?.field === 'id') normalized[field] = applyStrip(value);
+    }
+    return normalized;
+};
+export { normalizeOutputRecordIds };

package/dist/betterAuth/server/surrealDbAdapter/utils/normalizeRecordIds.d.ts

@@ -0,0 +1,2 @@
+import type { NormalizeRecordIds } from './types';
+export declare const normalizeRecordIds: ({ model, data, getDefaultModelName, getDefaultFieldName, getFieldAttributes, getModelName, }: NormalizeRecordIds) => Record<string, unknown>;

package/dist/betterAuth/server/surrealDbAdapter/utils/normalizeRecordIds.js

@@ -0,0 +1,38 @@
+import { RecordId } from "surrealdb";
+import { deserialize } from "../../../../surrealDB/index.js";
+const normalizeRecordIds = ({ model, data, getDefaultModelName, getDefaultFieldName, getFieldAttributes, getModelName })=>{
+    const normalized = {
+        ...data
+    };
+    const defaultModelName = getDefaultModelName(model);
+    const toRecordId = (target, raw)=>{
+        if (raw instanceof RecordId) return raw;
+        if ('string' == typeof raw) return raw.includes(':') ? deserialize(raw) : new RecordId(target, raw);
+        return raw;
+    };
+    for (const [field, value] of Object.entries(normalized)){
+        let defaultField;
+        try {
+            defaultField = getDefaultFieldName({
+                model: defaultModelName,
+                field
+            });
+        } catch  {
+            continue;
+        }
+        if ('id' === defaultField) continue;
+        const fieldAttr = getFieldAttributes({
+            model: defaultModelName,
+            field: defaultField
+        });
+        if (fieldAttr?.references?.field !== 'id') continue;
+        const targetModel = getModelName(fieldAttr.references.model);
+        if (Array.isArray(value)) {
+            normalized[field] = value.map((entry)=>toRecordId(targetModel, entry));
+            continue;
+        }
+        normalized[field] = toRecordId(targetModel, value);
+    }
+    return normalized;
+};
+export { normalizeRecordIds };

package/dist/betterAuth/server/surrealDbAdapter/utils/normalizeWhereValue.d.ts

@@ -0,0 +1,2 @@
+import type { NormalizeWhereValue } from './types';
+export declare const normalizeWhereValue: ({ model, field, value, getDefaultModelName, getDefaultFieldName, getModelName, getFieldAttributes, }: NormalizeWhereValue) => unknown;

package/dist/betterAuth/server/surrealDbAdapter/utils/normalizeWhereValue.js

@@ -0,0 +1,33 @@
+import { RecordId } from "surrealdb";
+import { deserialize } from "../../../../surrealDB/index.js";
+const normalizeWhereValue = ({ model, field, value, getDefaultModelName, getDefaultFieldName, getModelName, getFieldAttributes })=>{
+    const defaultModelName = getDefaultModelName(model);
+    const toRecordId = (target, raw)=>{
+        if (raw instanceof RecordId) return raw;
+        if ('string' == typeof raw) return raw.includes(':') ? deserialize(raw) : new RecordId(target, raw);
+        return raw;
+    };
+    let defaultField;
+    try {
+        defaultField = getDefaultFieldName({
+            model: defaultModelName,
+            field
+        });
+    } catch  {
+        return value;
+    }
+    if ('id' === defaultField) {
+        const targetModel = getModelName(defaultModelName);
+        if (Array.isArray(value)) return value.map((entry)=>toRecordId(targetModel, entry));
+        return toRecordId(targetModel, value);
+    }
+    const fieldAttr = getFieldAttributes({
+        model: defaultModelName,
+        field: defaultField
+    });
+    if (fieldAttr?.references?.field !== 'id') return value;
+    const targetModel = getModelName(fieldAttr.references.model);
+    if (Array.isArray(value)) return value.map((entry)=>toRecordId(targetModel, entry));
+    return toRecordId(targetModel, value);
+};
+export { normalizeWhereValue };

package/dist/betterAuth/server/surrealDbAdapter/utils/types.d.ts

@@ -0,0 +1,34 @@
+import type { JoinConfig, Where } from 'better-auth/adapters';
+import type { Args } from '../types';
+export type NormalizeRecordIds = Args & {
+    model: string;
+    data: object;
+};
+export type NormalizeOutputRecordIds = Args & {
+    model: string;
+    data: object | null;
+};
+export type NormalizeWhereValue = Args & {
+    model: string;
+    field: string;
+    value: unknown;
+};
+export type BuildExpression = Args & {
+    model: string;
+    where: Required<Where>[] | undefined;
+};
+export type BuildJoinPlan = Args & {
+    model: string;
+    join?: JoinConfig;
+};
+export type ApplyJoinMappings = Args & {
+    row: object | null;
+    mappings: Array<{
+        modelName: string;
+        sourceField: string;
+    }>;
+};
+export type SortBy = {
+    field: string;
+    direction: 'asc' | 'desc';
+};

package/dist/betterAuth/server/types.d.ts

@@ -0,0 +1,8 @@
+export type * from 'better-auth/client/plugins';
+export type * from 'better-auth/minimal';
+export type * from 'better-auth/plugins';
+export type InferUserWithRoles<TInferredUser extends {
+    role?: string | null;
+}, TRoles extends Record<string, unknown>> = Omit<TInferredUser, 'role'> & {
+    role: keyof TRoles;
+};

package/dist/betterAuth/useSessionUser.d.ts

@@ -0,0 +1 @@
+export declare const useSessionUser: <TUser = unknown>() => TUser | undefined;

package/dist/betterAuth/useSessionUser.js

@@ -0,0 +1,8 @@
+import { useRouteContext } from "@tanstack/react-router";
+const useSessionUser = ()=>{
+    const { user } = useRouteContext({
+        from: '__root__'
+    });
+    return user;
+};
+export { useSessionUser };

package/dist/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export * from './useMutation';
+export * from './useMutationWithInvalidate';

package/dist/hooks/index.js

@@ -0,0 +1,2 @@
+export * from "./useMutation.js";
+export * from "./useMutationWithInvalidate.js";

package/dist/styles.css

@@ -1,4 +1,4 @@
-.rolder-prompt-input-root {
+.rolder-chat-input-root {
   background-color: light-dark(var(--mantine-color-white), var(--mantine-color-dark-6));
 
   &:focus-within {
@@ -8,13 +8,13 @@
   }
 }
 
-.rolder-prompt-input-textarea {
+.rolder-chat-input-textarea {
   border: 0;
   border-radius: 8px;
   overflow: hidden;
 }
 
-.rolder-prompt-input-file-action-action {
+.rolder-chat-input-file-action-action {
   color: light-dark(var(--mantine-color-gray-7), var(--mantine-color-dark-1));
 
   &[data-disabled] {
@@ -62,11 +62,6 @@
   border-radius: var(--radius);
 }
 
-.rolder-scroll-area-content {
-  width: 100%;
-  height: 100%;
-}
-
 .rolder-scroll-area-scrollbar {
   border-top-right-radius: var(--radius);
   border-bottom-right-radius: var(--radius);

package/dist/surrealDB/deafaultCrud.d.ts

@@ -0,0 +1,2 @@
+export declare const surrealDeleteFn: import("@tanstack/react-start").RequiredFetcher<undefined, import("zod").ZodString, Promise<void>>;
+export declare const surrealUnsubscribeFn: import("@tanstack/react-start").RequiredFetcher<undefined, import("zod").ZodString, Promise<void>>;

package/dist/{surreal → surrealDB}/deafaultCrud.js

@@ -1,17 +1,18 @@
 import { createServerFn } from "@tanstack/react-start";
-import { getDB } from "./connection.js";
+import { getDBSession } from "../betterAuth/index.js";
+import { zodSchemas } from "../zodSchemas.js";
 import { deserialize } from "./deserialize.js";
 const surrealDeleteFn = createServerFn({
     method: 'POST'
-}).inputValidator((data)=>data).handler(async ({ data })=>{
-    const db = await getDB();
+}).inputValidator(zodSchemas.id).handler(async ({ data })=>{
+    const db = await getDBSession();
     const id = deserialize(data);
     await db.delete(id);
 });
 const surrealUnsubscribeFn = createServerFn({
     method: 'POST'
-}).inputValidator((data)=>data).handler(async ({ data })=>{
-    const db = await getDB();
+}).inputValidator(zodSchemas.id).handler(async ({ data })=>{
+    const db = await getDBSession();
     const live = await db.liveOf(data);
     await live.kill();
 });

package/dist/surrealDB/getDBInstance.d.ts

@@ -0,0 +1,3 @@
+import { Surreal } from 'surrealdb';
+import type { SurrealDBProps } from './types';
+export declare const getDBInstance: (params?: SurrealDBProps | undefined) => Promise<Surreal>;

package/dist/surrealDB/getDBInstance.js

@@ -0,0 +1,34 @@
+import { Surreal } from "surrealdb";
+let db = null;
+const getDBInstance = async (params = {})=>{
+    if (db?.isConnected) return db;
+    const instance = new Surreal();
+    try {
+        const url = params.url || process.env.SURREALDB_URL;
+        if (!url) throw new Error('Missing required SurrealDB URL');
+        const namespace = params.namespace || process.env.SURREALDB_NAMESPACE;
+        if (!namespace) throw new Error('Missing required SurrealDB namespace');
+        const database = params.database || process.env.SURREALDB_DATABASE;
+        if (!database) throw new Error('Missing required SurrealDB database');
+        const username = params.username || process.env.SURREALDB_USERNAME;
+        const password = params.password || process.env.SURREALDB_PASSWORD;
+        if (username && password) await instance.connect(url, {
+            authentication: {
+                username,
+                password
+            }
+        });
+        else await instance.connect(url);
+        await instance.use({
+            namespace,
+            database
+        });
+        db = instance;
+        return instance;
+    } catch (error) {
+        console.error('Failed to connect to SurrealDB:', error);
+        db = null;
+        throw error;
+    }
+};
+export { getDBInstance };

package/dist/surrealDB/getDBInstanceTanstack.d.ts

@@ -0,0 +1,3 @@
+import { Surreal } from 'surrealdb';
+import type { SurrealDBProps } from './types';
+export declare const getDBInstanceTanstack: (params?: SurrealDBProps | undefined) => Promise<Surreal>;

package/dist/{surreal/connection.js → surrealDB/getDBInstanceTanstack.js}

@@ -2,7 +2,7 @@ import { createServerOnlyFn } from "@tanstack/react-start";
 import { getCookie } from "@tanstack/react-start/server";
 import { DateTime, Surreal } from "surrealdb";
 let db = null;
-const getDB = createServerOnlyFn(async (params = {})=>{
+const getDBInstanceTanstack = createServerOnlyFn(async (params = {})=>{
     if (db?.isConnected) return db;
     const locale = getCookie('locale') || 'ru-RU';
     const timeZone = getCookie('tz') || 'UTC';
@@ -46,4 +46,4 @@ const getDB = createServerOnlyFn(async (params = {})=>{
         throw error;
     }
 });
-export { getDB };
+export { getDBInstanceTanstack };

package/dist/surrealDB/index.d.ts

@@ -0,0 +1,6 @@
+export * from 'surrealdb';
+export * from './deafaultCrud';
+export * from './deserialize';
+export * from './encryption';
+export * from './getDBInstance';
+export * from './getDBInstanceTanstack';

package/dist/surrealDB/index.js

@@ -0,0 +1,6 @@
+export * from "surrealdb";
+export * from "./deafaultCrud.js";
+export * from "./deserialize.js";
+export * from "./encryption.js";
+export * from "./getDBInstance.js";
+export * from "./getDBInstanceTanstack.js";

package/dist/{surreal/connection.d.ts → surrealDB/types.d.ts}

@@ -1,9 +1,9 @@
-import { type CodecOptions, Surreal } from 'surrealdb';
-export declare const getDB: (params?: {
+import type { CodecOptions } from 'surrealdb';
+export interface SurrealDBProps {
     url?: string;
     namespace?: string;
     database?: string;
     username?: string;
     password?: string;
     codecOptions?: CodecOptions;
-} | undefined) => Promise<Surreal>;
+}

package/dist/tanstack/cookie/index.d.ts

@@ -0,0 +1,3 @@
+export { getCookie } from './getCookie';
+export { setCookie } from './setCookie';
+export { setCookies } from './setCookies';

package/dist/tanstack/cookie/index.js

@@ -0,0 +1,4 @@
+import { getCookie } from "./getCookie.js";
+import { setCookie } from "./setCookie.js";
+import { setCookies } from "./setCookies.js";
+export { getCookie, setCookie, setCookies };

package/dist/{functions → tanstack/cookie}/setCookie.d.ts

@@ -7,4 +7,4 @@
  * @param {string} value - Значение куки, если не указано, кука будет удалена
  * @param {number} [expires=7] - Количество дней до истечения срока действия куки (по умолчанию 7 дней)
  */
-export declare const setCookie: import("@tanstack/start-fn-stubs").IsomorphicFn<[name: string, value?: string | undefined, expires?: number | undefined], void, void>;
+export declare const setCookie: import("@tanstack/react-start").IsomorphicFn<[name: string, value?: string | undefined, expires?: number | undefined], void, void>;

package/dist/tanstack/index.d.ts

@@ -0,0 +1,3 @@
+export * from './cookie';
+export * from './middlewares';
+export * from './s3';

package/dist/tanstack/index.js

@@ -0,0 +1,3 @@
+export * from "./cookie/index.js";
+export * from "./middlewares/index.js";
+export * from "./s3/index.js";

package/dist/tanstack/middlewares/index.d.ts

@@ -0,0 +1,6 @@
+import { locale } from './locale';
+export { locale };
+export declare const defaultRequestMiddlewares: import("@tanstack/react-start").RequestMiddlewareAfterServer<{}, undefined, {
+    locale: string;
+    timeZone: string;
+}>[];

package/dist/tanstack/middlewares/index.js

@@ -0,0 +1,5 @@
+import { locale } from "./locale.js";
+const defaultRequestMiddlewares = [
+    locale
+];
+export { defaultRequestMiddlewares, locale };

package/dist/tanstack/middlewares/locale.d.ts

@@ -0,0 +1,4 @@
+export declare const locale: import("@tanstack/react-start").RequestMiddlewareAfterServer<{}, undefined, {
+    locale: string;
+    timeZone: string;
+}>;