@signal24/vue-foundation 4.2.1 → 4.2.4

package/dist/src/directives/infinite-scroll.d.ts

@@ -1,3 +1,4 @@
 import type { ObjectDirective } from 'vue';
-import { type IInfiniteScrollOptions } from '../hooks/infinite-scroll';
-export declare const vInfiniteScroll: ObjectDirective<Element, IInfiniteScrollOptions>;
+type InfiniteScrollBindingValue = () => void;
+export declare const vInfiniteScroll: ObjectDirective<Element, InfiniteScrollBindingValue>;
+export {};

package/dist/src/helpers/openapi.d.ts

@@ -14,10 +14,15 @@ interface IRequestOptions {
 interface IBaseHttpRequest {
     request<T>(options: IRequestOptions): ICancelablePromise<T>;
 }
-interface IApiClient {
+export interface IApiClient {
     request: IBaseHttpRequest;
 }
-declare class ICancelablePromise<T = any> {
+export interface IApiError extends Error {
+    status: number;
+    statusText: string;
+    body: any;
+}
+export declare class ICancelablePromise<T = any> {
     constructor(executor: (resolve: (value: any) => void, reject: (reason: any) => void, onCancel: (cancel: () => void) => void) => void);
     then<TResult1 = any, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
     catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<T | TResult>;
@@ -30,5 +35,6 @@ interface IWrappedApiClientOptions<P extends ICancelablePromise = ICancelablePro
     onError?: (err: Error, options: IRequestOptions) => Error | null | void;
     CancelablePromise: new (...arguments_: Arguments) => P;
 }
+export declare function isApiError(err: any): err is IApiError;
 export declare function installApiClientInterceptors({ apiClient, onRequest, onError, CancelablePromise }: IWrappedApiClientOptions): void;
 export {};

package/dist/src/helpers/string.d.ts

@@ -3,3 +3,4 @@ export declare function nl2br(value: string): string;
 export declare function desnakeCase(value: string): string;
 export declare function formatPhone(value: string): string;
 export declare function formatUSCurrency(value: string | number): string;
+export declare function uuid(): string;

package/dist/src/vite-plugins/vite-openapi-plugin.cli.js

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 import { existsSync } from 'fs';
-import { generateOpenapiClient } from './vite-openapi-plugin.js';
+import { generateOpenapiClient, loadOpenapiOverrides } from './vite-openapi-plugin.js';
 if (!process.argv[2]) {
-    throw new Error('Usage: vf-generate-openapi-client <openapi-yaml-path>');
+    throw new Error('Usage: vf-generate-openapi-client <openapi-yaml-path> [<openapi-output-path>]');
 }
 if (!existsSync(process.argv[2])) {
     throw new Error(`OpenAPI YAML file not found: ${process.argv[2]}`);
 }
-await generateOpenapiClient(process.argv[2]);
+loadOpenapiOverrides();
+await generateOpenapiClient(process.argv[2], process.argv[3]);

package/dist/src/vite-plugins/vite-openapi-plugin.d.ts

@@ -1,7 +1,8 @@
-export declare function openapiClientGeneratorPlugin(openapiYamlPath: string): {
+export declare function loadOpenapiOverrides(): void;
+export declare function openapiClientGeneratorPlugin(openapiYamlPath: string, outPath?: string): {
     name: string;
-    apply: string;
+    apply: 'serve';
     buildStart(): void;
     closeBundle(): void;
 };
-export declare function generateOpenapiClient(openapiYamlPath: string): Promise<void>;
+export declare function generateOpenapiClient(openapiYamlPath: string, outPath?: string): Promise<void>;

package/dist/src/vite-plugins/vite-openapi-plugin.js

@@ -1,39 +1,60 @@
 import { createHash } from 'node:crypto';
-import { existsSync, readFileSync, watch } from 'node:fs';
+import { copyFileSync, existsSync, readFileSync, watch } from 'node:fs';
 import { rm } from 'node:fs/promises';
 import * as OpenAPI from 'openapi-typescript-codegen';
+const DEFAULT_OUT_PATH = './src/openapi-client-generated';
 let generatedHash = null;
-export function openapiClientGeneratorPlugin(openapiYamlPath) {
+let overridesMap = null;
+let overridesInverseMap = null;
+export function loadOpenapiOverrides() {
+    if (!existsSync('./openapi-specs.dev.json')) {
+        return;
+    }
+    try {
+        const overridesContent = readFileSync('./openapi-specs.dev.json', 'utf8');
+        overridesMap = JSON.parse(overridesContent);
+        overridesInverseMap = Object.fromEntries(Object.entries(overridesMap).map(([k, v]) => [v, k]));
+    }
+    catch (e) {
+        console.error('Failed to load openapi-specs.dev.json:', e);
+    }
+}
+export function openapiClientGeneratorPlugin(openapiYamlPath, outPath = DEFAULT_OUT_PATH) {
     let generator = null;
     return {
         name: 'openapi-types-generator',
         apply: 'serve',
         buildStart() {
-            generator = getGenerator(openapiYamlPath);
+            // apply a slight delay so any output doesn't get pushed off screen
+            setTimeout(() => {
+                loadOpenapiOverrides();
+                generator = getGenerator(openapiYamlPath, outPath);
+            }, 250);
         },
         closeBundle() {
             generator?.close();
         }
     };
 }
-function getGenerator(openapiYamlPath) {
-    if (!existsSync(openapiYamlPath)) {
-        console.log(`OpenAPI YAML file not found: ${openapiYamlPath}`);
+function getGenerator(openapiYamlPath, outPath) {
+    const resolvedPath = overridesMap?.[openapiYamlPath] ?? openapiYamlPath;
+    if (!existsSync(resolvedPath)) {
+        console.log(`OpenAPI YAML file not found: ${resolvedPath}`);
         return null;
     }
-    const watcher = watch(openapiYamlPath);
+    const watcher = watch(resolvedPath);
     watcher.on('change', () => {
         // give the writes a moment to settle
-        setTimeout(() => generateOpenapiClient(openapiYamlPath), 100);
+        setTimeout(() => generateOpenapiClient(resolvedPath, outPath), 100);
     });
-    generateOpenapiClient(openapiYamlPath);
+    generateOpenapiClient(resolvedPath, outPath);
     return {
         close() {
             watcher.close();
         }
     };
 }
-export async function generateOpenapiClient(openapiYamlPath) {
+async function generateOpenapiClientInternal(openapiYamlPath, outPath = DEFAULT_OUT_PATH) {
     const yaml = readFileSync(openapiYamlPath, 'utf8');
     const hash = createHash('sha256').update(yaml).digest('hex');
     if (hash === generatedHash) {
@@ -42,21 +63,28 @@ export async function generateOpenapiClient(openapiYamlPath) {
     generatedHash = hash;
     try {
         try {
-            await rm('./src/openapi-client-generated', { recursive: true });
+            await rm(outPath, { recursive: true });
         }
         catch (e) {
             // ignore
         }
         await OpenAPI.generate({
             input: openapiYamlPath,
-            output: './src/openapi-client-generated',
+            output: outPath,
             clientName: 'ApiClient',
             useOptions: true,
             useUnionTypes: true
         });
-        console.log(`[${new Date().toISOString()}] Generated client from ${openapiYamlPath} to ./src/openapi-client/`);
+        if (overridesInverseMap?.[openapiYamlPath]) {
+            copyFileSync(openapiYamlPath, overridesInverseMap[openapiYamlPath]);
+        }
+        console.log(`[${new Date().toISOString()}] Generated client from ${openapiYamlPath} to ${outPath}/`);
     }
     catch (err) {
         console.error(`[${new Date().toISOString()}] Error generating client from ${openapiYamlPath}:`, err);
     }
 }
+export async function generateOpenapiClient(openapiYamlPath, outPath = DEFAULT_OUT_PATH) {
+    const resolvedPath = overridesMap?.[openapiYamlPath] ?? openapiYamlPath;
+    return generateOpenapiClientInternal(resolvedPath, outPath);
+}