@signal24/vue-foundation 4.2.2 → 4.3.0

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/vite-plugins/vite-openapi-plugin.cli.js

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

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

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

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

@@ -1,40 +1,67 @@
 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;
+let generatorMap = {};
 let overridesMap = null;
-export function loadOpenapiOverrides() {
-    if (!existsSync('./openapi-specs.overrides.json')) {
+let overridesInverseMap = null;
+export function loadOpenapiConfig() {
+    loadGeneratorMap();
+    loadOverridesMap();
+}
+function loadGeneratorMap() {
+    if (!existsSync('./openapi-specs.json')) {
+        console.error('openapi-specs.json not found. Cannot generate OpenAPI client.');
+        return;
+    }
+    try {
+        const specsContent = readFileSync('./openapi-specs.json', 'utf8');
+        generatorMap = JSON.parse(specsContent);
+    }
+    catch (e) {
+        console.error('Failed to load openapi-specs.json:', e);
+    }
+}
+function loadOverridesMap() {
+    if (!existsSync('./openapi-specs.dev.json')) {
         return;
     }
     try {
-        const overridesContent = readFileSync('./openapi-specs.overrides.json', 'utf8');
+        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.overrides.json:', e);
+        console.error('Failed to load openapi-specs.dev.json:', e);
     }
 }
-export function openapiClientGeneratorPlugin(openapiYamlPath, outPath = DEFAULT_OUT_PATH) {
-    let generator = null;
+export function openapiClientGeneratorPlugin() {
+    let generators = null;
     return {
         name: 'openapi-types-generator',
         apply: 'serve',
         buildStart() {
             // apply a slight delay so any output doesn't get pushed off screen
             setTimeout(() => {
-                loadOpenapiOverrides();
-                generator = getGenerator(openapiYamlPath, outPath);
+                generators = createWatchfulGenerators();
             }, 250);
         },
         closeBundle() {
-            generator?.close();
+            if (generators) {
+                for (const generator of generators) {
+                    generator?.close();
+                }
+            }
         }
     };
 }
-function getGenerator(openapiYamlPath, outPath) {
+function createWatchfulGenerators() {
+    loadOpenapiConfig();
+    return Object.entries(generatorMap).map(([openapiYamlPath, outPath]) => createWatchfulGenerator(openapiYamlPath, outPath));
+}
+function createWatchfulGenerator(openapiYamlPath, outPath) {
     const resolvedPath = overridesMap?.[openapiYamlPath] ?? openapiYamlPath;
     if (!existsSync(resolvedPath)) {
         console.log(`OpenAPI YAML file not found: ${resolvedPath}`);
@@ -52,7 +79,14 @@ function getGenerator(openapiYamlPath, outPath) {
         }
     };
 }
-async function generateOpenapiClientInternal(openapiYamlPath, outPath = DEFAULT_OUT_PATH) {
+export async function generateConfiguredOpenapiClients() {
+    loadOpenapiConfig();
+    for (const [openapiYamlPath, outPath] of Object.entries(generatorMap)) {
+        const resolvedPath = overridesMap?.[openapiYamlPath] ?? openapiYamlPath;
+        await generateOpenapiClient(resolvedPath, outPath);
+    }
+}
+export async function generateOpenapiClient(openapiYamlPath, outPath = DEFAULT_OUT_PATH) {
     const yaml = readFileSync(openapiYamlPath, 'utf8');
     const hash = createHash('sha256').update(yaml).digest('hex');
     if (hash === generatedHash) {
@@ -73,13 +107,12 @@ async function generateOpenapiClientInternal(openapiYamlPath, outPath = DEFAULT_
             useOptions: true,
             useUnionTypes: true
         });
+        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);
-}