@witchcraft/nuxt-electron 0.0.1

package/dist/module.mjs

@@ -0,0 +1,362 @@
+import { crop } from '@alanscodelog/utils/crop';
+import { run } from '@alanscodelog/utils/run';
+import { defineNuxtModule, useLogger, createResolver, addComponentsDir, installModule, addTemplate, extendRouteRules, addImportsDir } from '@nuxt/kit';
+import { nuxtRemoveUneededPages, nuxtFileBasedRouting, nuxtRerouteOutputTo, createConstantCaseVariables } from '@witchcraft/nuxt-utils/utils';
+import { defu } from 'defu';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { startup, build } from 'vite-plugin-electron';
+import { notBundle } from 'vite-plugin-electron/plugin';
+import { externalizeDeps } from 'vite-plugin-externalize-deps';
+
+startup.exit = async () => {
+  if ("electronApp" in process) {
+    try {
+      const app = process.electronApp;
+      app.removeAllListeners();
+      process.kill(app.pid);
+    } catch (e) {
+      console.error("Could not kill electron instance/s.");
+      console.error(e);
+    }
+  }
+};
+const module = defineNuxtModule({
+  meta: {
+    name: "electron",
+    configKey: "electron"
+  },
+  // Default configuration options of the Nuxt module
+  defaults: {
+    srcDir: "~~/app-electron",
+    electronBuildDir: "~~/.dist/electron",
+    nonElectronNuxtBuildDir: "~~/.dist/web/.output",
+    devUserDataDir: "~~/.user-data-dir",
+    electronRoute: "/app",
+    autoOpen: process.env.AUTO_OPEN?.includes("electron"),
+    electronBuildPackScript: "npm run build:electron:pack",
+    additionalRoutes: [],
+    extraCliArgs: [],
+    enable: true,
+    electronOnlyRuntimeConfig: {},
+    usePreloadScript: true,
+    electronViteOptions: {},
+    additionalElectronVariables: {},
+    additionalViteDefinesToCopy: [],
+    notBundleOptions: {}
+  },
+  async setup(options, nuxt) {
+    if (!options.enable) {
+      return;
+    }
+    const moduleName = "@witchcraft/nuxt-electron";
+    const logger = useLogger(moduleName);
+    const { resolvePath, resolve } = createResolver(import.meta.url);
+    addComponentsDir({
+      global: true,
+      path: resolve("runtime/components")
+    });
+    await installModule("@witchcraft/ui/nuxt", nuxt.options.witchcraftUi);
+    addTemplate({
+      filename: "witchcraft-electron.css",
+      write: true,
+      getContents: () => crop`
+				@source "${resolve("runtime/components")}";
+			`
+    });
+    const isDev = nuxt.options.dev;
+    const srcDir = await resolvePath(options.srcDir, nuxt.options.alias);
+    const nonElectronNuxtBuildDir = await resolvePath(options.nonElectronNuxtBuildDir, nuxt.options.alias);
+    const electronRootBuildDir = await resolvePath(options.electronBuildDir, nuxt.options.alias);
+    const relativeElectronDir = path.relative(nuxt.options.rootDir, electronRootBuildDir);
+    const electronNuxtDir = path.join(relativeElectronDir, ".output");
+    const electronBuildDir = path.join(relativeElectronDir, "build");
+    const electronProdUrl = `${options.electronRoute}/index.html`;
+    const electronRoute = options.electronRoute;
+    const electronNuxtPublicDir = path.join(electronNuxtDir, "public");
+    const mainScriptPath = path.join(srcDir, "main.ts");
+    const preloadScriptPath = path.join(srcDir, "preload.ts");
+    const hasMainScript = await fs.stat(mainScriptPath).then(() => true).catch(() => false);
+    const hasPreloadScript = !options.usePreloadScript || await fs.stat(preloadScriptPath).then(() => true).catch(() => false);
+    const hasScripts = hasMainScript && hasPreloadScript;
+    if (!hasScripts) {
+      logger.warn(`Missing electron scripts: ${[hasMainScript ? "" : "main.ts", hasPreloadScript ? "" : "preload.ts"].join(", ")}. Skipping electron build.`);
+    }
+    const isElectronBuild = process.env.BUILD_ELECTRON === "true" && hasScripts;
+    const skipElectronPack = process.env.SKIP_ELECTRON_PACK === "true";
+    const autoOpen = !!(options.autoOpen && hasScripts && isDev);
+    const useWatch = nuxt.options.dev;
+    const devUserDataDir = options.devUserDataDir && await resolvePath(options.devUserDataDir, nuxt.options.alias);
+    if (devUserDataDir) {
+      if (!await fs.stat(devUserDataDir).then(() => true).catch(() => false)) {
+        await fs.mkdir(devUserDataDir, {
+          recursive: true
+        });
+      }
+    }
+    logger.debug({
+      isDev,
+      useWatch,
+      srcDir,
+      prodNonElectronNuxtDir: nonElectronNuxtBuildDir,
+      electronRootBuildDir,
+      relativeElectronDir,
+      electronNuxtDir,
+      electronBuildDir,
+      electronProdUrl,
+      electronRoute,
+      electronNuxtPublicDir,
+      mainScriptPath,
+      preloadScriptPath,
+      isElectronBuild,
+      skipElectronPack,
+      autoOpen,
+      devUserDataDir
+    });
+    let resolveGetViteServer;
+    const viteServerPromise = new Promise((resolve2) => {
+      resolveGetViteServer = resolve2;
+    });
+    nuxt.hook("vite:serverCreated", (server) => {
+      logger.info(`Resolved vite server.`);
+      resolveGetViteServer(server);
+    });
+    const viteServerUrl = new Promise((resolve2) => {
+      nuxt.hook("build:before", () => {
+        resolve2(void 0);
+      });
+      nuxt.hook("listen", (_server, listener) => {
+        logger.info(`Resolved server url.`, listener.url);
+        resolve2(listener.url);
+      });
+    });
+    const viteConfigPromise = new Promise((resolve2) => {
+      nuxt.hook("vite:configResolved", (config) => {
+        resolve2(config);
+      });
+    });
+    let maybeWatchers;
+    let started = false;
+    nuxt.hook("vite:extendConfig", (config) => {
+      config.define ??= {};
+      config.define["import.meta.electron"] = "false";
+      config.define["process.electron"] = "false";
+    });
+    const buildElectron = async () => {
+      if (maybeWatchers || started) return;
+      started = true;
+      const viteConfig = await viteConfigPromise;
+      const electronRuntimeConfig = defu(
+        options.electronOnlyRuntimeConfig,
+        nuxt.options.runtimeConfig.public
+      );
+      const additionalElectronVariables = defu(
+        options.additionalElectronVariables,
+        nuxt.options.electron.additionalElectronVariables
+      );
+      const additionalViteDefinesToCopy = [
+        ...options.additionalViteDefinesToCopy,
+        ...nuxt.options.electron.additionalViteDefinesToCopy ?? []
+      ];
+      const copyFromVite = [
+        "__NUXT_VERSION__",
+        "process.dev",
+        "import.meta.dev",
+        "process.test",
+        "import.meta.test",
+        ...additionalViteDefinesToCopy
+      ];
+      const electronVariables = {
+        "process.electron": true,
+        "import.meta.electron": true,
+        ...Object.fromEntries(
+          copyFromVite.map((v) => [v, viteConfig.define[v]])
+        ),
+        ...createConstantCaseVariables({
+          electronRoute,
+          electronProdUrl,
+          electronNuxtDir,
+          electronNuxtPublicDir,
+          electronBuildDir,
+          // ...options.additionalElectronVariables,
+          // nuxt's runtimeConfig cannot be used in electron's main since it's built seperately
+          // also we must stringify ourselves since escaped double quotes are not preserved in the final output :/
+          electronRuntimeConfig: JSON.stringify(electronRuntimeConfig).replaceAll("\\", "\\\\")
+        }, "process.env."),
+        // wut am having issue with just using STATIC. directly ???
+        ...createConstantCaseVariables(
+          additionalElectronVariables,
+          "process.env.",
+          { autoquote: false }
+        )
+      };
+      const electronViteOptions = defu(
+        {
+          build: {
+            // must be false or preload can get deleted when vite rebuilds
+            emptyOutDir: false
+          }
+        },
+        options.electronViteOptions,
+        {
+          build: {
+            outDir: electronBuildDir,
+            minify: false
+          },
+          define: electronVariables,
+          resolve: {
+            alias: nuxt.options.alias,
+            extensions: [".mjs", ".js", ".ts", ".jsx", ".tsx", ".json", ".vue"]
+          },
+          plugins: [externalizeDeps()]
+        }
+      );
+      const electronCliArgs = [
+        ".",
+        ...process.env.NODE_ENV !== "production" && devUserDataDir ? [
+          "--user-data-dir",
+          devUserDataDir
+        ] : [],
+        ...options.extraCliArgs ?? []
+      ];
+      const builds = [
+        {
+          entry: mainScriptPath,
+          onStart: autoOpen ? async () => {
+            await startup([...electronCliArgs]);
+          } : void 0
+        },
+        ...options.usePreloadScript ? [{
+          entry: preloadScriptPath,
+          onStart: async () => {
+            (await viteServerPromise).hot.send({ type: "full-reload" });
+          },
+          build: {
+            rollupOptions: {
+              output: {
+                inlineDynamicImports: true
+              }
+            }
+          }
+        }] : []
+      ].map((entry) => ({
+        vite: {
+          mode: process.env.NODE_ENV,
+          ...electronViteOptions,
+          build: {
+            watch: useWatch ? {
+              include: [`${srcDir}/**/*`]
+            } : null,
+            lib: {
+              entry: entry.entry,
+              formats: entry.entry.includes("preload") ? ["cjs"] : ["es"],
+              fileName: () => entry.entry.includes("preload") ? "[name].cjs" : "[name].mjs"
+            },
+            ...electronViteOptions.build
+          },
+          plugins: [
+            autoOpen ? {
+              name: "plugin-start-electron",
+              async closeBundle() {
+                void entry.onStart?.();
+              }
+            } : void 0,
+            // not bundle breaks preload because it tries to required from node_modules
+            // and sandboxed windows can't do that
+            ...!isElectronBuild && !entry.entry.includes("preload") ? [notBundle(options.notBundleOptions)] : [],
+            ...electronViteOptions.plugins ?? []
+          ]
+        }
+      }));
+      logger.debug(builds);
+      const devUrl = await viteServerUrl;
+      if (devUrl) {
+        Object.assign(process.env, {
+          VITE_DEV_SERVER_URL: devUrl.slice(0, -1)
+        });
+      }
+      logger.debug({
+        electronViteOptions,
+        prodNonElectronNuxtDir: nonElectronNuxtBuildDir,
+        electronVariables,
+        electronRuntimeConfig,
+        electronCliArgs,
+        devUrl
+      });
+      maybeWatchers = await Promise.all(builds.map(
+        async (config) => build(config).then((res) => {
+          logger.info(`Build done.`);
+          return res;
+        }).catch((err) => {
+          logger.error(`Build failed.`, err);
+          process.exit(1);
+        })
+      ));
+      if (useWatch) {
+        for (const maybeWatcher of maybeWatchers) {
+          if (maybeWatcher && "on" in maybeWatcher) {
+            maybeWatcher.on("change", (e) => {
+              logger.info(`Detected change in: ${e}`);
+            });
+          }
+        }
+      }
+    };
+    if (autoOpen) {
+      nuxt.hook("close", async () => {
+        logger.info(`Killing`);
+        await startup?.exit();
+      });
+      nuxt.hook("restart", async () => {
+        logger.info(`Killing and Restarting`);
+        await startup?.exit();
+      });
+    }
+    logger.info(`Building Electron: ${isElectronBuild}`);
+    if (isElectronBuild) {
+      nuxt.hook("build:manifest", (manifest) => {
+        for (const key of Object.keys(manifest)) {
+          manifest[key].dynamicImports = [];
+        }
+      });
+      nuxtRemoveUneededPages(nuxt, ["/", electronRoute, ...options.additionalRoutes]);
+      extendRouteRules(electronRoute, { ssr: false, prerender: true }, { override: true });
+      nuxt.options.router = defu(
+        nuxtFileBasedRouting().router,
+        nuxt.options.router ?? {}
+      );
+      nuxtRerouteOutputTo(nuxt, electronNuxtDir);
+      nuxt.hook("close", async () => {
+        logger.info(`Building Electron`);
+        await buildElectron();
+        if (!skipElectronPack) {
+          logger.info(`Packing Electron`);
+          const buildCommand = run(options.electronBuildPackScript, {
+            stdio: "inherit"
+          });
+          await buildCommand.promise.catch((err) => {
+            logger.error("Error building electron.", err);
+            process.exit(1);
+          });
+        } else {
+          logger.info(`Skipping Electron Pack`);
+        }
+        logger.info(`Done Building Electron`);
+      });
+    } else {
+      if (isDev) {
+        nuxt.hook("ready", async () => {
+          logger.info("electron - ready");
+          void buildElectron();
+        });
+        logger.info(`Watching Electron`);
+      } else {
+        logger.info(`Skipping Electron Build`);
+      }
+      nuxtRerouteOutputTo(nuxt, nonElectronNuxtBuildDir);
+    }
+    addImportsDir(resolve("runtime/utils"));
+  }
+});
+
+export { module as default };

package/dist/runtime/components/ElectronWindowControls.d.vue.ts

@@ -0,0 +1,31 @@
+import { type Component } from "vue";
+import type { WindowControlsApi } from "../electron/types.js.js";
+type __VLS_Props = {
+    borderWidth?: string;
+    buttonSize?: string;
+    borderRadius?: string;
+    /**
+     *
+     * Replace any of the default buttons with your own components.
+     *
+     * Note that you can get the existing button components (import from `/components/WIndowControls/[name]`) and pass a slot to change the icon then pass your new component here.
+     *
+     * If using a completely custom component, it must emit an `action` event with the action name as the value.
+     *
+     * This wrapper component sets the following css variables if you need them:
+     * `--electron-wc-size`
+     * `--electron-wc-border`
+     * `--electron-wc-rounded`
+     * `--electron-wc-diagonal` (useful for creating the close cross)
+     */
+    components?: Partial<Record<"CloseButton" | "MinimizeButton" | "MaximizeButton" | "PinButton", Component>>;
+    buttonsOrder?: ("CloseButton" | "MinimizeButton" | "MaximizeButton" | "PinButton")[];
+    handler?: WindowControlsApi;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    borderWidth: string;
+    buttonSize: string;
+    borderRadius: string;
+    buttonsOrder: ("CloseButton" | "MinimizeButton" | "MaximizeButton" | "PinButton")[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/runtime/components/ElectronWindowControls.vue

@@ -0,0 +1,67 @@
+<template>
+<ClientOnly>
+	<div
+		v-if="isElectron()"
+		:class="twMerge(`
+		flex
+		items-center
+		gap-2
+	`, $attrs.class)"
+		v-bind="{ ...$attrs, class: void 0 }"
+		:style="`
+		--electron-wc-size:${props.buttonSize};
+		--electron-wc-border:${props.borderWidth};
+		--electron-wc-rounded:${props.borderRadius};
+		--electron-wc-diagonal:calc((var(--electron-wc-size) - var(--electron-wc-border)/2)*sqrt(2));
+	`"
+	>
+		<template
+			v-for="button in buttonsOrder"
+			:key="button"
+		>
+			<component
+				:is="componentsMap[button]"
+				@action="actionHandler($event)"
+			/>
+		</template>
+	</div>
+</ClientOnly>
+</template>
+
+<script setup>
+import { computed, useAttrs } from "vue";
+import CloseButton from "./WindowControls/CloseButton.vue";
+import MaximizeButton from "./WindowControls/MaximizeButton.vue";
+import MinimizeButton from "./WindowControls/MinimizeButton.vue";
+import PinButton from "./WindowControls/PinButton.vue";
+import { twMerge } from "#imports";
+import { isElectron } from "../utils/isElectron.js";
+const $attrs = useAttrs();
+const props = defineProps({
+  borderWidth: { type: String, required: false, default: "2px" },
+  buttonSize: { type: String, required: false, default: "15px" },
+  borderRadius: { type: String, required: false, default: "1.5px" },
+  components: { type: Object, required: false },
+  buttonsOrder: { type: Array, required: false, default: () => ["PinButton", "MinimizeButton", "MaximizeButton", "CloseButton"] },
+  handler: { type: Function, required: false }
+});
+const componentsMap = computed(() => ({
+  CloseButton,
+  MinimizeButton,
+  MaximizeButton,
+  PinButton,
+  ...props.components
+}));
+const actionHandler = computed(() => {
+  if (!isElectron()) return void 0;
+  if (!props.handler) {
+    const defaultHandlerPath = window.electron?.api?.ui?.windowAction;
+    if (defaultHandlerPath) {
+      return defaultHandlerPath;
+    } else {
+      console.warn("No ElectronWindowControls handler specified and could not find default handler at `window.electron.api.ui.windowAction`");
+    }
+  }
+  return props.handler;
+});
+</script>

package/dist/runtime/components/ElectronWindowControls.vue.d.ts

@@ -0,0 +1,31 @@
+import { type Component } from "vue";
+import type { WindowControlsApi } from "../electron/types.js.js";
+type __VLS_Props = {
+    borderWidth?: string;
+    buttonSize?: string;
+    borderRadius?: string;
+    /**
+     *
+     * Replace any of the default buttons with your own components.
+     *
+     * Note that you can get the existing button components (import from `/components/WIndowControls/[name]`) and pass a slot to change the icon then pass your new component here.
+     *
+     * If using a completely custom component, it must emit an `action` event with the action name as the value.
+     *
+     * This wrapper component sets the following css variables if you need them:
+     * `--electron-wc-size`
+     * `--electron-wc-border`
+     * `--electron-wc-rounded`
+     * `--electron-wc-diagonal` (useful for creating the close cross)
+     */
+    components?: Partial<Record<"CloseButton" | "MinimizeButton" | "MaximizeButton" | "PinButton", Component>>;
+    buttonsOrder?: ("CloseButton" | "MinimizeButton" | "MaximizeButton" | "PinButton")[];
+    handler?: WindowControlsApi;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    borderWidth: string;
+    buttonSize: string;
+    borderRadius: string;
+    buttonsOrder: ("CloseButton" | "MinimizeButton" | "MaximizeButton" | "PinButton")[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/runtime/components/WindowControls/CloseButton.d.vue.ts

@@ -0,0 +1,16 @@
+declare var __VLS_10: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_10) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    action: (action: "close") => any;
+}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{
+    onAction?: ((action: "close") => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/WindowControls/CloseButton.vue

@@ -0,0 +1,54 @@
+<template>
+<WButton
+	:border="false"
+	aria-label="Close"
+	class="
+			p-0
+			[&:hover_.default-icon:after]:bg-accent-500
+			[&:hover_.default-icon:before]:bg-accent-500
+[&:hover_.default-icon:after]:shadow-xs
+			[&:hover_.default-icon:after]:shadow-fg/50
+			[&:hover_.default-icon:before]:shadow-xs
+			[&:hover_.default-icon:before]:shadow-fg/50
+
+		"
+	@click="emit('action', 'close')"
+>
+	<slot>
+		<div
+			class="
+			default-icon
+			relative
+			w-[calc(var(--electron-wc-size)-var(--electron-wc-border)/2)]
+			h-[calc(var(--electron-wc-size)-var(--electron-wc-border)/2)]
+			before:absolute
+			before:content-['']
+			before:left-0
+			before:rotate-45
+			before:origin-left
+			before:top-[calc(var(--electron-wc-border)/-2)]
+			before:w-[var(--electron-wc-diagonal)]
+			before:h-[var(--electron-wc-border)]
+			before:rounded-(--electron-wc-rounded)
+			before:bg-fg
+			dark:before:bg-bg
+			after:absolute
+			after:content-['']
+			after:origin-top
+			after:right-[calc(var(--electron-wc-border)/-2)]
+			after:top-0
+			after:rotate-[45deg]
+			after:h-[var(--electron-wc-diagonal)]
+			after:w-[var(--electron-wc-border)]
+			after:bg-fg
+			after:rounded-(--electron-wc-rounded)
+			dark:after:bg-bg
+		"
+		/>
+	</slot>
+</WButton>
+</template>
+
+<script setup>
+const emit = defineEmits(["action"]);
+</script>

package/dist/runtime/components/WindowControls/CloseButton.vue.d.ts

@@ -0,0 +1,16 @@
+declare var __VLS_10: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_10) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    action: (action: "close") => any;
+}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{
+    onAction?: ((action: "close") => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/WindowControls/MaximizeButton.d.vue.ts

@@ -0,0 +1,16 @@
+declare var __VLS_10: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_10) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    action: (action: "toggleMaximize") => any;
+}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{
+    onAction?: ((action: "toggleMaximize") => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/WindowControls/MaximizeButton.vue

@@ -0,0 +1,33 @@
+<template>
+<WButton
+	:border="false"
+	aria-label="Toggle Maximize"
+	class="
+			p-0
+			[&:hover_.default-icon]:border-accent-500
+			[&:hover_.default-icon]:shadow-xs
+			[&:hover_.default-icon]:shadow-fg/50
+
+		"
+	@click="emit('action', 'toggleMaximize')"
+>
+	<slot>
+		<div
+			class="
+				default-icon
+				border-fg
+				dark:border-bg
+				hover:border-accent-500
+				border-[length:var(--electron-wc-border)]
+				rounded-(--electron-wc-rounded)
+				w-[var(--electron-wc-size)]
+				h-[var(--electron-wc-size)]
+			"
+		/>
+	</slot>
+</WButton>
+</template>
+
+<script setup>
+const emit = defineEmits(["action"]);
+</script>

package/dist/runtime/components/WindowControls/MaximizeButton.vue.d.ts

@@ -0,0 +1,16 @@
+declare var __VLS_10: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_10) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    action: (action: "toggleMaximize") => any;
+}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{
+    onAction?: ((action: "toggleMaximize") => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/WindowControls/MinimizeButton.d.vue.ts

@@ -0,0 +1,16 @@
+declare var __VLS_10: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_10) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    action: (action: "minimize") => any;
+}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{
+    onAction?: ((action: "minimize") => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};