@hybridly/vite 0.3.1 → 0.4.1

package/dist/index.cjs

@@ -2,23 +2,19 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-const config = require('@hybridly/config');
 const laravel = require('laravel-vite-plugin');
 const path = require('node:path');
-const vite = require('vite');
+const fs = require('node:fs');
 const makeDebugger = require('debug');
 const localPkg = require('local-pkg');
-const fs = require('node:fs');
-const throttleDebounce = require('throttle-debounce');
-const node_child_process = require('node:child_process');
 const node_util = require('node:util');
+const node_child_process = require('node:child_process');
 const run = require('vite-plugin-run');
 const utils = require('@hybridly/utils');
 const autoimport = require('unplugin-auto-import/vite');
 const vueComponents = require('unplugin-vue-components/vite');
 const resolvers = require('unplugin-vue-components/resolvers');
 const iconsResolver = require('unplugin-icons/resolver');
-const glob = require('fast-glob');
 const icons = require('unplugin-icons/vite');
 const loaders = require('unplugin-icons/loaders');
 const vue = require('@vitejs/plugin-vue');
@@ -27,27 +23,174 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 
 const laravel__default = /*#__PURE__*/_interopDefaultLegacy(laravel);
 const path__default = /*#__PURE__*/_interopDefaultLegacy(path);
-const makeDebugger__default = /*#__PURE__*/_interopDefaultLegacy(makeDebugger);
 const fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+const makeDebugger__default = /*#__PURE__*/_interopDefaultLegacy(makeDebugger);
 const run__default = /*#__PURE__*/_interopDefaultLegacy(run);
 const autoimport__default = /*#__PURE__*/_interopDefaultLegacy(autoimport);
 const vueComponents__default = /*#__PURE__*/_interopDefaultLegacy(vueComponents);
 const iconsResolver__default = /*#__PURE__*/_interopDefaultLegacy(iconsResolver);
-const glob__default = /*#__PURE__*/_interopDefaultLegacy(glob);
 const icons__default = /*#__PURE__*/_interopDefaultLegacy(icons);
 const vue__default = /*#__PURE__*/_interopDefaultLegacy(vue);
 
-const ROUTING_PLUGIN_NAME = "vite:hybridly:routing";
-const ROUTING_HMR_UPDATE_ROUTING = "hybridly:routing:update";
-const ROUTING_HMR_QUERY_UPDATE_ROUTING = "hybridly:routing:pls-update";
-const ROUTING_VIRTUAL_MODULE_ID = "virtual:hybridly/router";
-const RESOLVED_ROUTING_VIRTUAL_MODULE_ID = `\0${ROUTING_VIRTUAL_MODULE_ID}`;
 const LAYOUT_PLUGIN_NAME = "vite:hybridly:layout";
 const CONFIG_PLUGIN_NAME = "vite:hybridly:config";
 const CONFIG_VIRTUAL_MODULE_ID = "virtual:hybridly/config";
 const RESOLVED_CONFIG_VIRTUAL_MODULE_ID = `\0${CONFIG_VIRTUAL_MODULE_ID}`;
 
+const debug = {
+  config: makeDebugger__default(CONFIG_PLUGIN_NAME),
+  layout: makeDebugger__default(LAYOUT_PLUGIN_NAME)
+};
+function isPackageInstalled(name, paths = [process.cwd()]) {
+  return localPkg.isPackageExists(name, { paths });
+}
+function toKebabCase(key) {
+  const result = key.replace(/([A-Z])/g, " $1").trim();
+  return result.split(" ").join("-").toLowerCase();
+}
+
+function generateTsConfig(options, config) {
+  const tsconfig = {
+    compilerOptions: {
+      target: "esnext",
+      module: "esnext",
+      moduleResolution: "node",
+      strict: true,
+      jsx: "preserve",
+      sourceMap: true,
+      resolveJsonModule: true,
+      esModuleInterop: true,
+      allowSyntheticDefaultImports: true,
+      lib: [
+        "esnext",
+        "dom"
+      ],
+      types: [
+        "vite/client",
+        "hybridly/client",
+        ...options.icons !== false ? ["unplugin-icons/types/vue"] : []
+      ],
+      baseUrl: "..",
+      paths: {
+        "#/*": [
+          ".hybridly/*"
+        ],
+        "~/*": [
+          "./*"
+        ],
+        "@/*": [
+          `./${config.architecture.root}/*`
+        ]
+      }
+    },
+    include: [
+      ...config.components.views.map(({ path: path2 }) => `../${path2}`),
+      ...config.components.layouts.map(({ path: path2 }) => `../${path2}`),
+      ...config.components.components.map(({ path: path2 }) => `../${path2}`),
+      `../${config.architecture.root}/**/*`,
+      "./*"
+    ],
+    exclude: [
+      "../public/**/*",
+      "../node_modules",
+      "../vendor"
+    ]
+  };
+  write(JSON.stringify(tsconfig, null, 2), "tsconfig.json");
+}
+function generateLaravelIdeaHelper(config) {
+  const ideJson = {
+    $schema: "https://laravel-ide.com/schema/laravel-ide-v2.json",
+    completions: [
+      {
+        complete: "staticStrings",
+        options: {
+          strings: config.components.views.map(({ identifier }) => identifier)
+        },
+        condition: [
+          {
+            functionNames: ["hybridly"],
+            parameters: [1]
+          }
+        ]
+      }
+    ]
+  };
+  write(JSON.stringify(ideJson, null, 2), "ide.json");
+}
+async function generateRouteDefinitionFile(options, config) {
+  const routing = config?.routing;
+  if (!routing) {
+    return;
+  }
+  debug.config("Writing types for routing:", routing);
+  const routes = Object.fromEntries(Object.entries(routing.routes).map(([key, route]) => {
+    const bindings = route.bindings ? Object.fromEntries(Object.entries(route.bindings).map(([key2]) => [key2, "__key_placeholder__"])) : void 0;
+    return [key, {
+      ...route.uri ? { uri: route.uri } : {},
+      ...route.domain ? { domain: route.domain } : {},
+      ...route.wheres ? { wheres: route.wheres } : {},
+      ...route.bindings ? { bindings } : {}
+    }];
+  }));
+  const definitions = `
+		/* eslint-disable */
+		/* prettier-ignore */
+		// This file has been automatically generated by Hybridly
+		// Modifications will be discarded
+		
+		declare module 'hybridly' {
+			export interface GlobalRouteCollection {
+				url: '__URL__'
+				routes: __ROUTES__
+			}
+		}
+		
+		export {}
+	`.replace("__URL__", routing?.url ?? "").replace("__ROUTES__", JSON.stringify(routes).replaceAll('"__key_placeholder__"', "any"));
+  write(definitions, "routes.d.ts");
+}
+function write(data, filename) {
+  const hybridlyPath = path__default.resolve(process.cwd(), ".hybridly");
+  if (!fs__default.existsSync(hybridlyPath)) {
+    fs__default.mkdirSync(hybridlyPath);
+  }
+  fs__default.writeFileSync(path__default.resolve(hybridlyPath, filename), data, {
+    encoding: "utf-8"
+  });
+}
+
+const shell = node_util.promisify(node_child_process.exec);
+async function loadConfiguration(options) {
+  try {
+    const php = options.php ?? process.env.PHP_EXECUTABLE_PATH ?? "php";
+    const { stdout } = await shell(`${php} artisan hybridly:config`);
+    return JSON.parse(stdout);
+  } catch (e) {
+    console.error("Could not load configuration from [php artisan].");
+    throw e;
+  }
+}
+
+function getClientCode(config) {
+  const paths = config.components.views.map(({ path }) => `"~/${path}"`).join(",");
+  return `
+		import { initializeHybridly as init } from 'hybridly/vue'
+
+		export function initializeHybridly(config) {
+			return init({
+				...${JSON.stringify(config)},
+				imported: import.meta.glob([${paths}], { eager: ${config.components.eager ?? true} }),
+				...config,
+			})
+		}
+ `;
+}
+
 const initialize = (options, config) => {
+  generateTsConfig(options, config);
+  generateLaravelIdeaHelper(config);
+  generateRouteDefinitionFile(options, config);
   return {
     name: CONFIG_PLUGIN_NAME,
     enforce: "pre",
@@ -55,7 +198,7 @@ const initialize = (options, config) => {
       return {
         resolve: {
           alias: {
-            "@": path__default.join(process.cwd(), config.root),
+            "@": path__default.join(process.cwd(), config.architecture.root),
             "#": path__default.join(process.cwd(), ".hybridly"),
             "~": path__default.join(process.cwd())
           }
@@ -63,19 +206,36 @@ const initialize = (options, config) => {
       };
     },
     configureServer(server) {
-      const reloadServer = (file) => {
-        if (!file.endsWith("hybridly.config.ts")) {
+      let restarting = false;
+      async function forceRestart(message) {
+        if (restarting) {
           return;
         }
-        server.config.logger.info("Hybridly configuration file was changed: forcing a server restart.", {
+        restarting = true;
+        server.config.logger.info(`${message}: forcing a server restart.`, {
           clear: server.config.clearScreen,
           timestamp: true
         });
-        server?.restart();
-      };
-      server.watcher.on("add", reloadServer);
-      server.watcher.on("change", reloadServer);
-      server.watcher.on("unlink", reloadServer);
+        return await server?.restart();
+      }
+      async function handleFileChange(file) {
+        if (file.endsWith("config/hybridly.php")) {
+          return await forceRestart("Configuration file changed");
+        }
+        if (/routes\/.*\.php/.test(file) || /routes\.php/.test(file)) {
+          return await forceRestart("Routing changed");
+        }
+        if (/.*\.vue$/.test(file)) {
+          const updatedConfig = await loadConfiguration(options);
+          const pagesOrLayoutsChanged = didPagesOrLayoutsChange(updatedConfig, config);
+          if (pagesOrLayoutsChanged) {
+            return await forceRestart("Page or layout changed");
+          }
+        }
+      }
+      server.watcher.on("add", handleFileChange);
+      server.watcher.on("change", handleFileChange);
+      server.watcher.on("unlink", handleFileChange);
     },
     resolveId(id) {
       if (id === CONFIG_VIRTUAL_MODULE_ID) {
@@ -84,60 +244,30 @@ const initialize = (options, config) => {
     },
     async load(id) {
       if (id === RESOLVED_CONFIG_VIRTUAL_MODULE_ID) {
-        return `
-					import { initializeHybridly as init } from 'hybridly/vue'
-					import '${ROUTING_VIRTUAL_MODULE_ID}'
-
-					export function initializeHybridly(config) {
-						return init({
-							...${JSON.stringify(config)},
-							components: import.meta.glob("${config.pagesGlob}", { eager: ${config.eager ?? true} }),
-							...config,
-						})
-					}
-				`;
+        return getClientCode(config);
+      }
+    },
+    async handleHotUpdate(ctx) {
+      if (ctx.file.includes(".hybridly")) {
+        return [];
       }
     }
   };
 };
-
-const debug = {
-  router: makeDebugger__default(ROUTING_PLUGIN_NAME),
-  layout: makeDebugger__default(LAYOUT_PLUGIN_NAME)
-};
-function isPackageInstalled(name, paths = [process.cwd()]) {
-  return localPkg.isPackageExists(name, { paths });
-}
-function toKebabCase(key) {
-  const result = key.replace(/([A-Z])/g, " $1").trim();
-  return result.split(" ").join("-").toLowerCase();
-}
-function getSubstringBetween(str, start, end) {
-  const startIndex = str.indexOf(start);
-  if (startIndex === -1) {
-    return;
-  }
-  const endIndex = str.indexOf(end, startIndex + start.length);
-  if (endIndex === -1) {
-    return;
+function didPagesOrLayoutsChange(updatedConfig, previousConfig) {
+  if (!previousConfig) {
+    return false;
   }
-  return str.substring(startIndex + start.length, endIndex);
+  return JSON.stringify(updatedConfig.components.views) !== JSON.stringify(previousConfig.components.views) || JSON.stringify(updatedConfig.components.layouts) !== JSON.stringify(previousConfig.components.layouts);
 }
 
 const TEMPLATE_LAYOUT_REGEX = /<template +layout(?: *= *['"]((?:[\w\/\-_,:](?:,\ )?)+)['"] *)?>/;
 const TYPESCRIPT_REGEX = /lang=['"]ts['"]/;
-const layout = (options, config$1) => {
+const layout = (options, config) => {
   const defaultLayoutName = options?.layout?.defaultLayoutName?.replace(".vue", "") ?? "default";
-  const layoutsDirectory = path__default.resolve(process.cwd(), config$1.root, config$1.layouts);
   const templateRegExp = options?.layout?.templateRegExp ?? TEMPLATE_LAYOUT_REGEX;
-  const resolveLayoutPath = (layoutName) => {
-    const [domain, layout] = layoutName.includes(":") ? layoutName.split(":") : [void 0, layoutName];
-    const layoutPath = path__default.resolve(config.resolveLayoutsDirectory(config$1, domain), `${layout}.vue`);
-    return vite.normalizePath(layoutPath).replaceAll("\\", "/");
-  };
   debug.layout("Resolved options:", {
-    defaultLayoutName,
-    layoutsDirectory
+    defaultLayoutName
   });
   return {
     name: LAYOUT_PLUGIN_NAME,
@@ -153,7 +283,7 @@ const layout = (options, config$1) => {
         const exports = layouts.map((_2, i) => importName(i));
         const imports = layouts.reduce((imports2, layoutName2, i) => `
 					${imports2}
-					import ${importName(i)} from '${resolveLayoutPath(layoutName2)}';
+					import ${importName(i)} from '${resolveLayoutImportPath(layoutName2, config)}';
 				`, "").trim();
         debug.layout(`Resolved layouts "${layouts.join(", ")}":`, {
           sourceFile: id,
@@ -171,134 +301,14 @@ const layout = (options, config$1) => {
     }
   };
 };
-
-function getRouterClientCode(routing) {
-  return `
-		if (typeof window !== 'undefined') {
-			window.hybridly = {
-				routing: ${JSON.stringify(routing)}
-			}
-
-			if (import.meta.hot) {
-				import.meta.hot.on('${ROUTING_HMR_UPDATE_ROUTING}', (routing) => {
-					window.dispatchEvent(new CustomEvent('hybridly:routing', { detail: routing }))
-				})
-
-				import.meta.hot.send('${ROUTING_HMR_QUERY_UPDATE_ROUTING}')
-			}
-		}
- `;
-}
-
-const shell = node_util.promisify(node_child_process.exec);
-async function fetchRoutingFromArtisan(options) {
-  try {
-    const php = options.php ?? "php";
-    const result = await shell(`${php} artisan hybridly:routes`);
-    const routing = JSON.parse(result.stdout);
-    write$1(options, routing);
-    return routing;
-  } catch {
+function resolveLayoutImportPath(name, config) {
+  const { path } = config.components.layouts.find((layout) => layout.identifier === name) ?? {};
+  if (!path) {
+    throw new Error(`Layout [${name}] could not be found.`);
   }
+  return `~/${path}`;
 }
 
-const write$1 = throttleDebounce.debounce(1e3, writeDefinitions, { atBegin: true });
-async function writeDefinitions(options, routing) {
-  routing ?? (routing = await fetchRoutingFromArtisan(options));
-  if (options.dts === false || !routing) {
-    return;
-  }
-  debug.router("Writing types for routing:", routing);
-  const target = path__default.resolve(options.dts ?? ".hybridly/routes.d.ts");
-  const routes = Object.fromEntries(Object.entries(routing.routes).map(([key, route]) => {
-    const bindings = route.bindings ? Object.fromEntries(Object.entries(route.bindings).map(([key2]) => [key2, "__key_placeholder__"])) : void 0;
-    return [key, {
-      ...route.uri ? { uri: route.uri } : {},
-      ...route.domain ? { domain: route.domain } : {},
-      ...route.wheres ? { wheres: route.wheres } : {},
-      ...route.bindings ? { bindings } : {}
-    }];
-  }));
-  const definitions = generateDefinitions().replace("__URL__", routing?.url ?? "").replace("__ROUTES__", JSON.stringify(routes).replaceAll('"__key_placeholder__"', "any"));
-  fs__default.mkdirSync(path__default.dirname(target), { recursive: true });
-  fs__default.writeFileSync(target, definitions, { encoding: "utf-8" });
-}
-function generateDefinitions() {
-  return `
-/* eslint-disable */
-/* prettier-ignore */
-// This file has been automatically generated by Hybridly
-// Modifications will be discarded
-
-declare module 'hybridly' {
-	export interface GlobalRouteCollection {
-		url: '__URL__'
-		routes: __ROUTES__
-	}
-}
-
-export {}`;
-}
-
-const router = (options, config) => {
-  const resolved = {
-    php: "php",
-    dts: ".hybridly/routes.d.ts",
-    watch: [
-      /routes\/.*\.php/
-    ],
-    ...options
-  };
-  let routingBeforeUpdate;
-  async function sendRoutingUpdate(server, force = false) {
-    const routing = await fetchRoutingFromArtisan(resolved) ?? routingBeforeUpdate;
-    if (force || JSON.stringify(routing) !== JSON.stringify(routingBeforeUpdate)) {
-      debug.router("Updating routes via HMR:", routing);
-      server.ws.send({
-        type: "custom",
-        event: ROUTING_HMR_UPDATE_ROUTING,
-        data: routing
-      });
-      write$1(resolved);
-      routingBeforeUpdate = routing;
-    }
-  }
-  return {
-    name: ROUTING_PLUGIN_NAME,
-    configureServer(server) {
-      write$1(resolved);
-      server.ws.on(ROUTING_HMR_QUERY_UPDATE_ROUTING, () => {
-        sendRoutingUpdate(server, true);
-      });
-      server.watcher.on("change", async (path) => {
-        if (!resolved.watch.some((regex) => regex.test(path))) {
-          return;
-        }
-        sendRoutingUpdate(server);
-      });
-    },
-    resolveId(id) {
-      if (id === ROUTING_VIRTUAL_MODULE_ID) {
-        return RESOLVED_ROUTING_VIRTUAL_MODULE_ID;
-      }
-    },
-    async load(id) {
-      if (id === RESOLVED_ROUTING_VIRTUAL_MODULE_ID) {
-        const routing = await fetchRoutingFromArtisan(resolved);
-        return getRouterClientCode(routing);
-      }
-    },
-    async handleHotUpdate(ctx) {
-      if (typeof resolved.dts === "string" && ctx.file.endsWith(resolved.dts)) {
-        return [];
-      }
-    },
-    transform() {
-      write$1(resolved);
-    }
-  };
-};
-
 function getRunOptions(options) {
   if (options.run === false) {
     return [];
@@ -324,7 +334,7 @@ function getRunOptions(options) {
 
 function getLaravelOptions(options, config) {
   return {
-    input: `${config.root}/application/main.ts`,
+    input: `${config.architecture.root}/application/main.ts`,
     ...options.laravel ?? {}
   };
 }
@@ -361,12 +371,9 @@ function getAutoImportsOptions(options, config) {
       vueTemplate: true,
       dts: ".hybridly/auto-imports.d.ts",
       dirs: [
-        `${config.root}/utils`,
-        `${config.root}/composables`,
-        ...config.domains ? [
-          `${config.root}/${config.domains}/**/utils`,
-          `${config.root}/${config.domains}/**/composables`
-        ] : []
+        `${config.architecture.root}/utils`,
+        `${config.architecture.root}/composables`,
+        ...config.components.directories.map((directory) => `${directory}/**/*.ts`)
       ],
       imports: [
         "vue",
@@ -402,18 +409,17 @@ function getVueComponentsOptions(options, config) {
   const customCollections = Array.isArray(options.customIcons) ? options.customIcons : options.customIcons?.collections ?? [];
   const overrideResolvers = options.overrideResolvers ? Array.isArray(options.overrideResolvers) ? options.overrideResolvers : [options.overrideResolvers] : false;
   const hasHeadlessUI = isPackageInstalled("@headlessui/vue");
-  const isUsingDomains = config.domains !== false;
   return utils.merge(
     {
       dirs: [
-        `./${config.root}/components`
+        `./${config.architecture.root}/components`
       ],
       directoryAsNamespace: true,
       dts: ".hybridly/components.d.ts",
       resolvers: overrideResolvers || [
         ...hasIcons ? [iconsResolver__default({ customCollections })] : [],
         ...hasHeadlessUI ? [resolvers.HeadlessUiResolver({ prefix: options?.vueComponents?.headlessUiPrefix ?? "Headless" })] : [],
-        ...isUsingDomains ? [DomainComponentsResolver(config)] : [],
+        ProvidedComponentListResolver(config),
         HybridlyResolver(options.vueComponents?.linkName)
       ]
     },
@@ -421,36 +427,21 @@ function getVueComponentsOptions(options, config) {
     { overwriteArray: false }
   );
 }
-function resolveComponentUsingPaths(config, paths, name, resolve) {
-  if (!config.domains) {
-    return;
-  }
-  const kebabName = `${toKebabCase(name)}.vue`;
-  for (const possiblePath of paths) {
-    const domain = getSubstringBetween(possiblePath, `${resolve(config.root, config.domains)}/`, "/components/");
-    if (!domain) {
-      continue;
-    }
-    const kebabPath = toKebabCase(possiblePath.replaceAll("/", "-")).replaceAll("--", "-").replace("components-", "");
-    if (kebabPath.endsWith(kebabName) && kebabName.includes(domain)) {
-      return possiblePath;
+function ProvidedComponentListResolver(config) {
+  function resolveComponentPath(name) {
+    const kebabName = toKebabCase(name);
+    const path = config.components.components.find((view) => {
+      const identifierAsComponentName = view.identifier.replace("::", "-").replace(".", "-");
+      return identifierAsComponentName === kebabName;
+    })?.path;
+    if (!path) {
+      return;
     }
+    return `~/${path}`;
   }
-}
-function DomainComponentsResolver(config) {
   return {
     type: "component",
-    resolve: (name) => {
-      if (config.domains === false) {
-        return;
-      }
-      return resolveComponentUsingPaths(
-        config,
-        glob__default.sync(`${path__default.resolve(process.cwd(), config.root, config.domains)}/**/*.vue`),
-        name,
-        path__default.resolve
-      );
-    }
+    resolve: (name) => resolveComponentPath(name)
   };
 }
 
@@ -462,7 +453,7 @@ function getIconsOptions(options, config) {
   const customIconDirectoryName = resolved?.icons ?? "icons";
   const customCollections = Object.fromEntries(resolved?.collections?.map((collection) => [
     collection,
-    loaders.FileSystemIconLoader(`./${config.root}/${customIconDirectoryName}/${collection}`)
+    loaders.FileSystemIconLoader(`./${config.architecture.root}/${customIconDirectoryName}/${collection}`)
   ]) ?? []);
   return {
     autoInstall: true,
@@ -494,96 +485,16 @@ function getVueOptions(options) {
   );
 }
 
-function generateTsConfig(options, config) {
-  const tsconfig = {
-    compilerOptions: {
-      target: "esnext",
-      module: "esnext",
-      moduleResolution: "node",
-      strict: true,
-      jsx: "preserve",
-      sourceMap: true,
-      resolveJsonModule: true,
-      esModuleInterop: true,
-      allowSyntheticDefaultImports: true,
-      lib: [
-        "esnext",
-        "dom"
-      ],
-      types: [
-        "vite/client",
-        "hybridly/client",
-        ...options.icons !== false ? ["unplugin-icons/types/vue"] : []
-      ],
-      baseUrl: "..",
-      paths: {
-        "#/*": [
-          ".hybridly/*"
-        ],
-        "~/*": [
-          "./*"
-        ],
-        "@/*": [
-          `./${config.root}/*`
-        ]
-      }
-    },
-    include: [
-      `../${config.root}/**/*`,
-      "./*"
-    ],
-    exclude: [
-      "../public/**/*",
-      "../node_modules",
-      "../vendor"
-    ]
-  };
-  write(JSON.stringify(tsconfig, null, 2), "tsconfig.json");
-}
-function generateLaravelIdeaHelper(config) {
-  const ideJson = {
-    $schema: "https://laravel-ide.com/schema/laravel-ide-v2.json",
-    completions: [
-      ...config.domains ? [] : [{
-        complete: "directoryFiles",
-        options: {
-          directory: `/${config.root}/${config.pages}`,
-          suffixToClear: ".vue"
-        },
-        condition: [
-          {
-            functionNames: ["hybridly"],
-            parameters: [1]
-          }
-        ]
-      }]
-    ]
-  };
-  write(JSON.stringify(ideJson, null, 2), "ide.json");
-}
-function write(data, filename) {
-  const hybridlyPath = path__default.resolve(process.cwd(), ".hybridly");
-  if (!fs__default.existsSync(hybridlyPath)) {
-    fs__default.mkdirSync(hybridlyPath);
-  }
-  fs__default.writeFileSync(path__default.resolve(hybridlyPath, filename), data, {
-    encoding: "utf-8"
-  });
-}
-
 async function plugin(options = {}) {
-  const config$1 = await config.loadHybridlyConfig();
-  generateTsConfig(options, config$1);
-  generateLaravelIdeaHelper(config$1);
+  const config = await loadConfiguration(options);
   return [
-    initialize(options, config$1),
-    layout(options, config$1),
-    router(options),
-    options.laravel !== false && laravel__default(getLaravelOptions(options, config$1)),
+    initialize(options, config),
+    layout(options, config),
+    options.laravel !== false && laravel__default(getLaravelOptions(options, config)),
     options.run !== false && run__default(getRunOptions(options)),
-    options.vueComponents !== false && vueComponents__default(getVueComponentsOptions(options, config$1)),
-    options.autoImports !== false && autoimport__default(getAutoImportsOptions(options, config$1)),
-    options.icons !== false && icons__default(getIconsOptions(options, config$1)),
+    options.vueComponents !== false && vueComponents__default(getVueComponentsOptions(options, config)),
+    options.autoImports !== false && autoimport__default(getAutoImportsOptions(options, config)),
+    options.icons !== false && icons__default(getIconsOptions(options, config)),
     options.vue !== false && vue__default(getVueOptions(options))
   ];
 }
@@ -592,4 +503,3 @@ exports.HybridlyImports = HybridlyImports;
 exports.HybridlyResolver = HybridlyResolver;
 exports["default"] = plugin;
 exports.layout = layout;
-exports.router = router;