nuxt-feathers-zod 0.1.0

package/dist/runtime/options/authentication/jwt.d.ts

@@ -0,0 +1,7 @@
+import type { AuthClientOptions } from './client.js';
+import type { SignOptions } from './jwt-types.js';
+export type AuthJwtOptions = Partial<SignOptions>;
+export declare const authJwtDefaults: AuthJwtOptions;
+export declare function getAuthJwtDefaults(): AuthJwtOptions;
+export declare const authClientJwtDefaults: AuthClientOptions;
+export declare function getAuthClientJwtDefaults(): AuthClientOptions;

package/dist/runtime/options/authentication/jwt.js

@@ -0,0 +1,19 @@
+import { klona } from "klona";
+export const authJwtDefaults = {
+  header: {
+    alg: "HS256",
+    typ: "access"
+  },
+  audience: "http://localhost",
+  algorithm: "HS256",
+  expiresIn: "1d"
+};
+export function getAuthJwtDefaults() {
+  return klona(authJwtDefaults);
+}
+export const authClientJwtDefaults = {
+  storageKey: "feathers-jwt"
+};
+export function getAuthClientJwtDefaults() {
+  return klona(authClientJwtDefaults);
+}

package/dist/runtime/options/authentication/local.d.ts

@@ -0,0 +1,8 @@
+export interface AuthLocalOptions {
+    hashSize?: number | undefined;
+    usernameField?: string;
+    passwordField?: string;
+    errorMessage?: string;
+}
+export declare const authLocalDefaults: AuthLocalOptions;
+export declare function getAuthLocalDefaults(): AuthLocalOptions;

package/dist/runtime/options/authentication/local.js

@@ -0,0 +1,8 @@
+import { klona } from "klona";
+export const authLocalDefaults = {
+  usernameField: "userId",
+  passwordField: "password"
+};
+export function getAuthLocalDefaults() {
+  return klona(authLocalDefaults);
+}

package/dist/runtime/options/client/index.d.ts

@@ -0,0 +1,14 @@
+import type { ModuleOptions } from '..';
+import type { PluginOptions, ResolvedPluginOptions } from '../plugins.js';
+import type { PiniaOptions } from './pinia.js';
+export interface ClientOptions extends PluginOptions {
+    pinia?: PiniaOptions | boolean;
+}
+export interface ResolvedClientOptions extends ResolvedPluginOptions {
+    pinia: PiniaOptions | false;
+}
+export type ResolvedClientOptionsOrDisabled = ResolvedClientOptions | false;
+export type ResolvedClientOnlyOptions = Omit<ResolvedClientOptions, 'pinia'>;
+export declare const clientDefaults: ResolvedClientOnlyOptions;
+export declare function getClientDefaults(): ResolvedClientOnlyOptions;
+export declare function resolveClientOptions(client: ModuleOptions['client'], mongodb: boolean, rootDir: string, srcDir: string): Promise<ResolvedClientOptionsOrDisabled>;

package/dist/runtime/options/client/index.js

@@ -0,0 +1,33 @@
+import { createResolver } from "@nuxt/kit";
+import defu from "defu";
+import { klona } from "klona";
+import { NuxtFeathersError } from "../../errors.js";
+import { preparePluginOptions, resolvePluginsOptions } from "../plugins.js";
+import { resolvePiniaOptions } from "./pinia.js";
+export const clientDefaults = {
+  plugins: []
+};
+export function getClientDefaults() {
+  return klona(clientDefaults);
+}
+export async function resolveClientOptions(client, mongodb, rootDir, srcDir) {
+  if (client === false)
+    return false;
+  let clientOptions;
+  const clientDefaults2 = getClientDefaults();
+  if (client === true || client === void 0) {
+    clientOptions = clientDefaults2;
+  } else if (typeof client === "object") {
+    clientOptions = defu(clientDefaults2, preparePluginOptions(client));
+  } else {
+    throw new NuxtFeathersError("Invalid client options");
+  }
+  const srcResolver = createResolver(srcDir);
+  const resolvedPlugins = await resolvePluginsOptions(clientOptions, rootDir, srcResolver.resolve("feathers"));
+  const pinia = resolvePiniaOptions(clientOptions.pinia, mongodb);
+  const resolvedClient = {
+    pinia,
+    ...resolvedPlugins
+  };
+  return resolvedClient;
+}

package/dist/runtime/options/client/pinia.d.ts

@@ -0,0 +1,14 @@
+import type { ModuleOptions as PiniaNuxtModuleOptions } from '@pinia/nuxt';
+import type { CreatePiniaClientConfig, PiniaServiceConfig } from 'feathers-pinia';
+export type PiniaModuleOptions = Pick<PiniaNuxtModuleOptions, 'storesDirs'>;
+export type removableServiceOptions = 'customizeStore' | 'handleEvents' | 'setupInstance' | 'customFilters' | 'customSiftOperators';
+export type SerializablePiniaServiceConfig = Omit<PiniaServiceConfig, removableServiceOptions>;
+export interface SerializablePiniaClientOptions extends Partial<Omit<CreatePiniaClientConfig, 'pinia' | 'services' | 'storage' | removableServiceOptions>> {
+    services?: Record<string, SerializablePiniaServiceConfig>;
+}
+export type PiniaOptions = SerializablePiniaClientOptions & PiniaModuleOptions;
+export type ResolvedPiniaOptions = Required<Pick<PiniaOptions, 'storesDirs' | 'idField'>> & Omit<PiniaOptions, 'storesDirs' | 'idField'>;
+export type ResolvedPiniaOptionsOrDisabled = ResolvedPiniaOptions | false;
+export declare const piniaDefaults: ResolvedPiniaOptions;
+export declare function getPiniaDefaults(mongodb: boolean): ResolvedPiniaOptions;
+export declare function resolvePiniaOptions(piniaOptions: PiniaOptions | boolean | undefined, mongodb: boolean): ResolvedPiniaOptionsOrDisabled;

package/dist/runtime/options/client/pinia.js

@@ -0,0 +1,22 @@
+import { klona } from "klona";
+export const piniaDefaults = {
+  storesDirs: ["stores"],
+  idField: "id"
+  // use _id for mongoDB
+};
+export function getPiniaDefaults(mongodb) {
+  const resolvedPiniaDefaults = klona(piniaDefaults);
+  if (mongodb) {
+    resolvedPiniaDefaults.idField = "_id";
+  }
+  return resolvedPiniaDefaults;
+}
+export function resolvePiniaOptions(piniaOptions, mongodb) {
+  let pinia = false;
+  const piniaDefaultOptions = getPiniaDefaults(mongodb);
+  if (piniaOptions === true || piniaOptions === void 0)
+    pinia = piniaDefaultOptions;
+  else if (piniaOptions !== false)
+    pinia = { ...piniaDefaultOptions, ...piniaOptions };
+  return pinia;
+}

package/dist/runtime/options/database/index.d.ts

@@ -0,0 +1,6 @@
+import type { MongoOptions } from './mongodb.js';
+export interface DataBaseOptions {
+    mongo?: MongoOptions;
+}
+export type ResolvedDataBaseOptions = DataBaseOptions;
+export declare function resolveDataBaseOptions(database: DataBaseOptions): ResolvedDataBaseOptions;

package/dist/runtime/options/database/index.js

@@ -0,0 +1,8 @@
+import { resolveMongoOptions } from "./mongodb.js";
+export function resolveDataBaseOptions(database) {
+  const resolvedDataBaseOptions = {};
+  if (database?.mongo) {
+    resolvedDataBaseOptions.mongo = resolveMongoOptions(database.mongo);
+  }
+  return resolvedDataBaseOptions;
+}

package/dist/runtime/options/database/mongodb.d.ts

@@ -0,0 +1,12 @@
+import type { MongoClientOptions } from 'mongodb';
+type PickSerializable<T> = {
+    [K in keyof T as NonNullable<T[K]> extends Function ? never : K]: T[K];
+};
+interface MongoUrlOption {
+    url: string;
+}
+type SerializableMongoClientOptions = PickSerializable<MongoClientOptions>;
+export type MongoOptions = MongoUrlOption & SerializableMongoClientOptions;
+export type ResolvedMongoOptions = MongoOptions;
+export declare function resolveMongoOptions(mongodb: MongoOptions): ResolvedMongoOptions;
+export {};

package/dist/runtime/options/database/mongodb.js

@@ -0,0 +1,3 @@
+export function resolveMongoOptions(mongodb) {
+  return mongodb;
+}

package/dist/runtime/options/index.d.ts

@@ -0,0 +1,44 @@
+import type { Nuxt } from '@nuxt/schema';
+import type { AuthOptions, PublicAuthOptions, ResolvedAuthOptions, ResolvedAuthOptionsOrDisabled } from './authentication/index.js';
+import type { ClientOptions, ResolvedClientOptionsOrDisabled } from './client/index.js';
+import type { PiniaOptions } from './client/pinia.js';
+import type { DataBaseOptions, ResolvedDataBaseOptions } from './database/index.js';
+import type { ResolvedServerOptions, ServerOptions } from './server.js';
+import type { ServicesDir, ServicesDirs } from './services.js';
+import type { ResolvedTransportsOptions, TransportsOptions } from './transports/index.js';
+import type { ResolvedValidatorOptions, ValidatorOptions } from './validator.js';
+export interface ModuleOptions {
+    transports: TransportsOptions;
+    database: DataBaseOptions;
+    servicesDirs: ServicesDir | ServicesDirs;
+    server: ServerOptions;
+    auth: AuthOptions | boolean;
+    client: ClientOptions | boolean;
+    validator: ValidatorOptions;
+    loadFeathersConfig: boolean;
+}
+export interface ResolvedOptions {
+    templateDir: string;
+    transports: ResolvedTransportsOptions;
+    database: ResolvedDataBaseOptions;
+    servicesDirs: ServicesDirs;
+    server: ResolvedServerOptions;
+    auth: ResolvedAuthOptionsOrDisabled;
+    client: ResolvedClientOptionsOrDisabled;
+    validator: ResolvedValidatorOptions;
+    loadFeathersConfig: boolean;
+}
+export interface FeathersRuntimeConfig {
+    auth?: ResolvedAuthOptions;
+}
+export interface FeathersPublicRuntimeConfig {
+    transports: ResolvedTransportsOptions;
+    auth?: PublicAuthOptions;
+    pinia?: PiniaOptions;
+}
+export type ModuleConfig = Partial<Omit<ModuleOptions, 'auth'> & {
+    auth: Omit<AuthOptions, 'entityImport'> | boolean;
+}>;
+export declare function resolveOptions(options: ModuleOptions, nuxt: Nuxt): Promise<ResolvedOptions>;
+export declare function resolveRuntimeConfig(options: ResolvedOptions): FeathersRuntimeConfig;
+export declare function resolvePublicRuntimeConfig(options: ResolvedOptions): FeathersPublicRuntimeConfig;

package/dist/runtime/options/index.js

@@ -0,0 +1,63 @@
+import { createResolver } from "@nuxt/kit";
+import { getServicesImports } from "../services.js";
+import { resolveAuthOptions } from "./authentication/index.js";
+import { resolveClientOptions } from "./client/index.js";
+import { resolveDataBaseOptions } from "./database/index.js";
+import { resolveServerOptions } from "./server.js";
+import { resolveServicesDirs } from "./services.js";
+import { resolveTransportsOptions } from "./transports/index.js";
+import { resolveValidatorOptions } from "./validator.js";
+export async function resolveOptions(options, nuxt) {
+  const { rootDir, srcDir, serverDir, appDir, buildDir, ssr } = nuxt.options;
+  const resolver = createResolver(import.meta.url);
+  const templateDir = /node_modules/.test(buildDir) ? resolver.resolve(rootDir, ".nuxt/feathers") : resolver.resolve(buildDir, "feathers");
+  const transports = resolveTransportsOptions(options.transports, ssr);
+  const database = resolveDataBaseOptions(options.database);
+  const servicesDirs = resolveServicesDirs(options.servicesDirs, rootDir);
+  const server = await resolveServerOptions(options.server, rootDir, serverDir);
+  const client = await resolveClientOptions(options.client, !!database.mongo, rootDir, srcDir);
+  const validator = resolveValidatorOptions(options.validator);
+  const servicesImports = await getServicesImports(servicesDirs);
+  const auth = resolveAuthOptions(options.auth, !!client, servicesImports, appDir);
+  const loadFeathersConfig = options.loadFeathersConfig;
+  const resolvedOptions = {
+    templateDir,
+    transports,
+    database,
+    servicesDirs,
+    server,
+    client,
+    validator,
+    auth,
+    loadFeathersConfig
+  };
+  console.dir(resolvedOptions, { depth: null });
+  return resolvedOptions;
+}
+export function resolveRuntimeConfig(options) {
+  const runtimeConfig = {};
+  if (options.auth) {
+    runtimeConfig.auth = options.auth;
+  }
+  return runtimeConfig;
+}
+export function resolvePublicRuntimeConfig(options) {
+  const publicRuntimeConfig = {
+    transports: options.transports
+  };
+  const auth = options.auth;
+  if (auth?.client) {
+    publicRuntimeConfig.auth = {
+      authStrategies: auth.authStrategies,
+      servicePath: auth.service,
+      entityKey: auth.entity,
+      entityClass: auth.entityClass,
+      client: auth.client
+    };
+  }
+  const client = options.client;
+  if (client?.pinia) {
+    publicRuntimeConfig.pinia = client.pinia;
+  }
+  return publicRuntimeConfig;
+}

package/dist/runtime/options/plugins.d.ts

@@ -0,0 +1,20 @@
+import type { Import } from 'unimport';
+import type { ModuleImport } from './utils.js';
+export type PluginDir = string;
+export type PluginDirs = Array<PluginDir>;
+export type Plugin = string | Import;
+export type Plugins = Array<Plugin>;
+export type Imports = Array<Import>;
+export type ResolvedPlugins = Array<ModuleImport>;
+export interface PluginOptions {
+    pluginDirs?: PluginDir | PluginDirs;
+    plugins?: Plugin | Plugins;
+}
+export interface ResolvedPluginOptions {
+    plugins: ResolvedPlugins;
+}
+export declare function preparePluginOptions(pluginOptions: PluginOptions): PluginOptions;
+export declare function resolvePluginDirs(pluginDirs: PluginDir | PluginDirs | undefined, rootDir: string, defaultDir: string): PluginDirs;
+export declare function resolvePluginsFromPluginDirs(pluginDirs: PluginDirs): Promise<ResolvedPlugins>;
+export declare function resolvePlugins(plugins: Plugin | Plugins | undefined, rootDir: string): Promise<ResolvedPlugins>;
+export declare function resolvePluginsOptions(pluginOptions: PluginOptions, rootDir: string, defaultDir: string): Promise<ResolvedPluginOptions>;

package/dist/runtime/options/plugins.js

@@ -0,0 +1,69 @@
+import { createResolver } from "@nuxt/kit";
+import { scanDirExports, scanExports } from "unimport";
+import { filterExports, setImportsMeta } from "./utils.js";
+function forceArray(value) {
+  if (!value)
+    return [];
+  return Array.isArray(value) ? value : [value];
+}
+export function preparePluginOptions(pluginOptions) {
+  const { pluginDirs, plugins } = pluginOptions;
+  return {
+    ...pluginOptions,
+    pluginDirs: forceArray(pluginDirs),
+    plugins: forceArray(plugins)
+  };
+}
+export function resolvePluginDirs(pluginDirs, rootDir, defaultDir) {
+  const rootResolver = createResolver(rootDir);
+  const resolvedPluginDirs = [];
+  if (pluginDirs && typeof pluginDirs === "string") {
+    resolvedPluginDirs.push(pluginDirs);
+  } else if (pluginDirs?.length) {
+    resolvedPluginDirs.push(...pluginDirs);
+  } else {
+    resolvedPluginDirs.push(defaultDir);
+  }
+  return resolvedPluginDirs.map((dir) => rootResolver.resolve(dir));
+}
+export async function resolvePluginsFromPluginDirs(pluginDirs) {
+  const imports = await scanDirExports(pluginDirs, {
+    filePatterns: ["*.ts"],
+    types: false
+  });
+  const filteredImports = imports.filter(filterExports);
+  const resolvedPlugins = setImportsMeta(filteredImports);
+  return resolvedPlugins;
+}
+export async function resolvePlugins(plugins, rootDir) {
+  if (!plugins)
+    return [];
+  const rootResolver = createResolver(rootDir);
+  const filteredImports = [];
+  for (const plugin of Array.isArray(plugins) ? plugins : [plugins]) {
+    if (typeof plugin === "string") {
+      const imports = await scanExports(rootResolver.resolve(plugin), false);
+      filteredImports.push(...imports.filter(filterExports));
+    } else {
+      filteredImports.push(plugin);
+    }
+  }
+  const resolvedPlugins = setImportsMeta(filteredImports);
+  return resolvedPlugins;
+}
+function removeDuplicates(plugins) {
+  return plugins.filter(
+    (plugin, index, self) => index === self.findIndex((p) => p.from === plugin.from)
+  );
+}
+export async function resolvePluginsOptions(pluginOptions, rootDir, defaultDir) {
+  const pluginDirs = resolvePluginDirs(pluginOptions.pluginDirs, rootDir, defaultDir);
+  const resolvedPlugins = [
+    ...await resolvePluginsFromPluginDirs(pluginDirs),
+    ...await resolvePlugins(pluginOptions.plugins, rootDir)
+  ];
+  const resolvedPluginOptions = {
+    plugins: removeDuplicates(resolvedPlugins)
+  };
+  return resolvedPluginOptions;
+}

package/dist/runtime/options/server.d.ts

@@ -0,0 +1,7 @@
+import type { ModuleOptions } from '.';
+import type { PluginOptions, ResolvedPluginOptions } from './plugins.js';
+export type ServerOptions = PluginOptions;
+export type ResolvedServerOptions = ResolvedPluginOptions;
+export declare const serverDefaults: ServerOptions;
+export declare const serverDirDefault = "feathers";
+export declare function resolveServerOptions(server: ModuleOptions['server'], rootDir: string, serverDir: string): Promise<ResolvedServerOptions>;

package/dist/runtime/options/server.js

@@ -0,0 +1,11 @@
+import { createResolver } from "@nuxt/kit";
+import { resolvePluginsOptions } from "./plugins.js";
+export const serverDefaults = {
+  pluginDirs: [],
+  plugins: []
+};
+export const serverDirDefault = "feathers";
+export async function resolveServerOptions(server, rootDir, serverDir) {
+  const serverResolver = createResolver(serverDir);
+  return resolvePluginsOptions(server, rootDir, serverResolver.resolve(serverDirDefault));
+}

package/dist/runtime/options/services.d.ts

@@ -0,0 +1,6 @@
+import type { ModuleOptions } from '.';
+export type ServicesDir = string;
+export type ServicesDirs = Array<ServicesDir>;
+export type ResolvedServicesDirs = [ServicesDir, ...ServicesDir[]];
+export declare const servicesDirDefault: ServicesDir;
+export declare function resolveServicesDirs(servicesDirs: ModuleOptions['servicesDirs'], rootDir: string): ResolvedServicesDirs;

package/dist/runtime/options/services.js

@@ -0,0 +1,13 @@
+import { createResolver } from "@nuxt/kit";
+export const servicesDirDefault = "services";
+export function resolveServicesDirs(servicesDirs, rootDir) {
+  const resolvedServicesDirs = [];
+  if (typeof servicesDirs === "string" && servicesDirs)
+    resolvedServicesDirs.push(servicesDirs);
+  if (Array.isArray(servicesDirs) && servicesDirs.find((v) => v))
+    resolvedServicesDirs.push(...servicesDirs.filter((v) => v));
+  if (!resolvedServicesDirs.length)
+    resolvedServicesDirs.push(servicesDirDefault);
+  const rootResolver = createResolver(rootDir);
+  return resolvedServicesDirs.map((dir) => rootResolver.resolve(dir));
+}

package/dist/runtime/options/transports/index.d.ts

@@ -0,0 +1,23 @@
+import type { ResolvedRestOptionsOrDisabled, RestOptions } from './rest.js';
+import type { ResolvedWebsocketOptionsOrDisabled, WebsocketOptions } from './websocket.js';
+export interface CommonTransportOptions {
+    path?: string;
+}
+export type TransportsOptions = {
+    rest: RestOptions | true;
+    websocket?: WebsocketOptions | boolean;
+} | {
+    rest?: RestOptions | boolean;
+    websocket: WebsocketOptions | true;
+} | {
+    rest?: never;
+    websocket: false;
+} | {
+    rest: false;
+    websocket?: never;
+};
+export interface ResolvedTransportsOptions {
+    rest: ResolvedRestOptionsOrDisabled;
+    websocket: ResolvedWebsocketOptionsOrDisabled;
+}
+export declare function resolveTransportsOptions(transports: TransportsOptions, ssr: boolean): ResolvedTransportsOptions;

package/dist/runtime/options/transports/index.js

@@ -0,0 +1,14 @@
+import { NuxtFeathersError } from "../../errors.js";
+import { resolveRestTransportsOptions } from "./rest.js";
+import { resolveWebsocketTransportsOptions } from "./websocket.js";
+export function resolveTransportsOptions(transports, ssr) {
+  const rest = resolveRestTransportsOptions(transports.rest, transports.websocket !== false, ssr);
+  const websocket = resolveWebsocketTransportsOptions(transports.websocket);
+  if (!rest && !websocket)
+    throw new NuxtFeathersError("No transport selected. Must be enable one of rest or websocket transport.");
+  const resolvedTransportsOptions = {
+    rest,
+    websocket
+  };
+  return resolvedTransportsOptions;
+}

package/dist/runtime/options/transports/rest.d.ts

@@ -0,0 +1,9 @@
+import type { CommonTransportOptions } from '.';
+export type Framework = 'koa' | 'express';
+export interface RestOptions extends CommonTransportOptions {
+    framework?: Framework;
+}
+export type ResolvedRestOptions = Required<RestOptions>;
+export type ResolvedRestOptionsOrDisabled = ResolvedRestOptions | false;
+export declare const restDefaults: ResolvedRestOptions;
+export declare function resolveRestTransportsOptions(rest: RestOptions | boolean | undefined, websocket: boolean, ssr: boolean): ResolvedRestOptionsOrDisabled;

package/dist/runtime/options/transports/rest.js

@@ -0,0 +1,22 @@
+import defu from "defu";
+import { checkPath } from "./utils.js";
+export const restDefaults = {
+  path: "/feathers",
+  framework: "koa"
+};
+function getRestDefaults(rest, websocket, ssr) {
+  if (rest === true || !websocket || ssr)
+    return restDefaults;
+  else
+    return false;
+}
+export function resolveRestTransportsOptions(rest, websocket, ssr) {
+  let resolvedRest = false;
+  if (rest === true || typeof rest === "undefined") {
+    resolvedRest = getRestDefaults(rest, websocket, ssr);
+  } else if (rest !== false) {
+    resolvedRest = defu(rest, restDefaults);
+    checkPath(resolvedRest.path);
+  }
+  return resolvedRest;
+}

package/dist/runtime/options/transports/utils.d.ts

@@ -0,0 +1 @@
+export declare function checkPath(path?: string): void;

package/dist/runtime/options/transports/utils.js

@@ -0,0 +1,7 @@
+import { NuxtFeathersError } from "../../errors.js";
+export function checkPath(path) {
+  if (!path?.startsWith("/"))
+    throw new NuxtFeathersError(`transport path option must start with /! Current path: ${path}`);
+  if (!/^[\w\-/.]+$/.test(path))
+    throw new NuxtFeathersError(`transport path option must be a valid URL path! ${path} is not valid.`);
+}

package/dist/runtime/options/transports/websocket.d.ts

@@ -0,0 +1,8 @@
+import type { CommonTransportOptions } from '.';
+export interface WebsocketOptions extends CommonTransportOptions {
+    connectTimeout?: number;
+}
+export type ResolvedWebsocketOptions = Required<WebsocketOptions>;
+export type ResolvedWebsocketOptionsOrDisabled = ResolvedWebsocketOptions | false;
+export declare const websocketDefaults: ResolvedWebsocketOptions;
+export declare function resolveWebsocketTransportsOptions(websocket: WebsocketOptions | boolean | undefined): ResolvedWebsocketOptionsOrDisabled;

package/dist/runtime/options/transports/websocket.js

@@ -0,0 +1,17 @@
+import defu from "defu";
+import { checkPath } from "./utils.js";
+export const websocketDefaults = {
+  path: "/socket.io",
+  connectTimeout: 45e3
+  // default settings for socket.io
+};
+export function resolveWebsocketTransportsOptions(websocket) {
+  let resolvedWebsocket = false;
+  if (websocket === true || websocket === void 0) {
+    resolvedWebsocket = websocketDefaults;
+  } else if (websocket !== false) {
+    resolvedWebsocket = defu(websocket, websocketDefaults);
+    checkPath(resolvedWebsocket.path);
+  }
+  return resolvedWebsocket;
+}

package/dist/runtime/options/utils.d.ts

@@ -0,0 +1,11 @@
+import type { Import } from 'unimport';
+export declare function filterExports({ name, from, as }: Import): boolean;
+export interface ModuleImport extends Import {
+    meta: {
+        importId: string;
+        import: string;
+    };
+}
+export declare function getImportId(p: string): string;
+export declare function setImportMeta(module: Import): ModuleImport;
+export declare function setImportsMeta(modules: Import[]): ModuleImport[];

package/dist/runtime/options/utils.js

@@ -0,0 +1,22 @@
+import path from "node:path";
+import { camelCase } from "change-case";
+import { hash } from "ohash";
+export function filterExports({ name, from, as }) {
+  return name === "default" || new RegExp(`^${as}w{0,2}`).test(camelCase(path.basename(from, path.extname(from))));
+}
+export function getImportId(p) {
+  return `_${hash(p).replace(/-/g, "").slice(0, 8)}`;
+}
+export function setImportMeta(module) {
+  const importId = getImportId(module.from);
+  const _import = module.name === "default" ? importId : `{ ${module.as} as ${importId} }`;
+  const _from = module.from.replace(/.ts$/, "");
+  module.meta = {
+    importId,
+    import: `import ${_import} from '${_from}'`
+  };
+  return module;
+}
+export function setImportsMeta(modules) {
+  return modules.map(setImportMeta);
+}

package/dist/runtime/options/validator.d.ts

@@ -0,0 +1,13 @@
+import type { FormatName } from 'ajv-formats';
+import type { ModuleOptions } from '.';
+export type ValidatorFormatsOptions = Array<FormatName>;
+export interface ValidatorOptions {
+    formats: ValidatorFormatsOptions;
+    extendDefaults: boolean;
+}
+export interface ResolvedValidatorOptions {
+    formats: ValidatorFormatsOptions;
+}
+export declare const validatorFormatsDefaults: ValidatorFormatsOptions;
+export declare function getValidatorDefaults(extendDefaults: boolean): ResolvedValidatorOptions;
+export declare function resolveValidatorOptions(validator: ModuleOptions['validator']): ResolvedValidatorOptions;

package/dist/runtime/options/validator.js

@@ -0,0 +1,29 @@
+import { klona } from "klona";
+export const validatorFormatsDefaults = [
+  "date-time",
+  "time",
+  "date",
+  "email",
+  "hostname",
+  "ipv4",
+  "ipv6",
+  "uri",
+  "uri-reference",
+  "uuid",
+  "uri-template",
+  "json-pointer",
+  "relative-json-pointer",
+  "regex"
+];
+export function getValidatorDefaults(extendDefaults) {
+  return { formats: extendDefaults ? klona(validatorFormatsDefaults) : [] };
+}
+export function resolveValidatorOptions(validator) {
+  if (!validator.formats.length)
+    return getValidatorDefaults(validator.extendDefaults);
+  const formats = validator.extendDefaults ? validator.formats.concat(validatorFormatsDefaults) : validator.formats;
+  const resolvedValidator = {
+    formats: Array.from(new Set(formats))
+  };
+  return resolvedValidator;
+}

package/dist/runtime/plugins/feathers-auth.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Client-side authentication bootstrap.
+ *
+ * Why: In SSR, the Feathers client plugin may not be available yet (or may be
+ * intentionally disabled) and calling the auth store would throw.
+ *
+ * We only attempt to re-authenticate in the browser and only when the Feathers
+ * client has been injected.
+ */
+declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/plugins/feathers-auth.js

@@ -0,0 +1,13 @@
+import { defineNuxtPlugin } from "#app";
+import { useAuthStore } from "../stores/auth.js";
+export default defineNuxtPlugin(async (nuxtApp) => {
+  if (import.meta.server)
+    return;
+  if (!("$api" in nuxtApp) || !nuxtApp.$api)
+    return;
+  const auth = useAuthStore();
+  try {
+    await auth.reAuthenticate();
+  } catch {
+  }
+});

package/dist/runtime/server/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../../.nuxt/tsconfig.server.json"
+}

package/dist/runtime/services.d.ts

@@ -0,0 +1,4 @@
+import type { Import } from 'unimport';
+import type { ServicesDirs } from './options/services.js';
+export declare function getServicesImports(servicesDirs: ServicesDirs): Promise<Import[]>;
+export declare function addServicesImports(imports: Import[]): Promise<void>;