@stacksjs/actions 0.70.88 → 0.70.91

package/dist/generate/index.js

@@ -0,0 +1,158 @@
+import * as fs from "node:fs";
+import process from "node:process";
+import { runCommand } from "@stacksjs/cli";
+import { Action, NpmScript } from "@stacksjs/enums";
+import { log } from "@stacksjs/logging";
+import { frameworkPath, projectPath, storagePath } from "@stacksjs/path";
+import { ExitCode } from "@stacksjs/types";
+import { runNpmScript } from "@stacksjs/utils";
+import { runAction } from "../helpers";
+import { generateVsCodeCustomData as genVsCodeCustomData } from "../helpers/vscode-custom-data";
+export async function invoke(options) {
+  if (options?.types)
+    await generateTypes(options);
+  else if (options?.entries)
+    await generateLibEntries(options);
+  else if (options?.webTypes)
+    await generateWebTypes(options);
+  else if (options?.customData)
+    await generateVsCodeCustomData();
+  else if (options?.ideHelpers)
+    await generateIdeHelpers(options);
+  else if (options?.componentMeta)
+    await generateComponentMeta();
+  else if (options?.coreSymlink)
+    await generateCoreSymlink();
+  else if (options?.openApiSpec)
+    await generateOpenApiSpec();
+}
+export function generate(options) {
+  return invoke(options);
+}
+export async function generateLibEntries(options) {
+  const result = await runAction(Action.GenerateLibraryEntries, {
+    ...options,
+    cwd: projectPath()
+  });
+  if (result.isErr) {
+    log.error("There was an error generating your library entry points", result.error);
+    process.exit(ExitCode.FatalError);
+  }
+  log.success("Library entry points generated successfully");
+}
+export async function generateWebTypes(options) {
+  const result = await runNpmScript(NpmScript.GenerateWebTypes, options);
+  if (result.isErr) {
+    log.error("There was an error generating the web-types.json file.", result.error);
+    process.exit(ExitCode.FatalError);
+  }
+  log.success("Successfully generated the web-types.json file");
+}
+export async function generateVsCodeCustomData() {
+  const result = await genVsCodeCustomData();
+  if (result.isErr) {
+    log.error("There was an error generating the custom-elements.json file.", result.error);
+    process.exit(ExitCode.FatalError);
+  }
+  await runAction(Action.LintFix, { verbose: !0, cwd: projectPath() });
+  log.success("Successfully generated the custom-elements.json file");
+}
+export async function generateIdeHelpers(options) {
+  const result = await runNpmScript(NpmScript.GenerateIdeHelpers, options);
+  if (result.isErr) {
+    log.error("There was an error generating IDE helpers.", result.error);
+    process.exit(ExitCode.FatalError);
+  }
+  await runAction(Action.LintFix, { verbose: !0, cwd: projectPath() });
+  log.success("Successfully generated IDE helpers");
+}
+export async function generateComponentMeta() {
+  const result = await genVsCodeCustomData();
+  if (result.isErr) {
+    log.error("There was an error generating your component meta information.", result.error);
+    process.exit(ExitCode.FatalError);
+  }
+  await runAction(Action.LintFix, { verbose: !0, cwd: projectPath() });
+  log.success("Successfully generated component meta information");
+}
+export async function generateTypes(options) {
+  const result = await runNpmScript(NpmScript.GenerateTypes, {
+    cwd: frameworkPath(),
+    ...options
+  });
+  if (result.isErr) {
+    log.error("There was an error generating your types.", result.error);
+    throw result.error instanceof Error ? result.error : Error(String(result.error));
+  }
+  log.success("Types were generated successfully");
+}
+export async function watchTypes(options) {
+  try {
+    const manifestPath = `${frameworkPath()}/package.json`, text = fs.existsSync(manifestPath) ? fs.readFileSync(manifestPath, "utf-8") : "";
+    if (!(text ? JSON.parse(text) : {})?.scripts?.["generate:types"]) {
+      log.warn("[generate:types --watch] no `generate:types` script in framework package.json \u2014 type regeneration disabled. dev:api will keep running, but type definitions won't auto-refresh on model/config changes.");
+      return;
+    }
+  } catch {}
+  const watched = [
+    projectPath("app/Models"),
+    storagePath("framework/defaults/app/Models"),
+    projectPath("config"),
+    projectPath("database/migrations")
+  ];
+  log.info(`[generate:types --watch] watching ${watched.length} directories`);
+  let pending = null, inflight = !1;
+  const trigger = () => {
+    if (pending)
+      clearTimeout(pending);
+    pending = setTimeout(async () => {
+      if (inflight)
+        return;
+      inflight = !0;
+      try {
+        log.info("[generate:types --watch] change detected, regenerating\u2026");
+        await generateTypes(options);
+        log.success("[generate:types --watch] types up to date");
+      } catch (err) {
+        log.error("[generate:types --watch] regeneration failed:", err);
+      } finally {
+        inflight = !1;
+      }
+    }, 200);
+  }, watchers = [];
+  for (const dir of watched)
+    try {
+      if (!fs.existsSync(dir))
+        continue;
+      const w = fs.watch(dir, { recursive: !0 }, () => trigger());
+      watchers.push(w);
+    } catch (err) {
+      log.warn(`[generate:types --watch] cannot watch ${dir}: ${err}`);
+    }
+  if (watchers.length === 0) {
+    log.warn("[generate:types --watch] no directories to watch \u2014 exiting");
+    return;
+  }
+  await new Promise((resolve) => {
+    process.once("SIGINT", () => {
+      log.info("[generate:types --watch] stopping");
+      for (const w of watchers)
+        try {
+          w.close();
+        } catch {}
+      resolve();
+    });
+  });
+}
+export function generatePantryConfig() {
+  log.success("Successfully generated `./pantry.yaml` based on your config");
+}
+export async function generateSeeder() {}
+export async function generateCoreSymlink() {
+  await runCommand(`ln -s ${frameworkPath()} ${projectPath(".stacks")}`);
+}
+export async function generateOpenApiSpec() {
+  const { generateOpenApi } = await import("@stacksjs/api");
+  await generateOpenApi();
+  log.success("Successfully generated Open API Spec");
+}

package/dist/generate/lib-entries.d.ts

@@ -0,0 +1 @@
+export declare function generateLibEntries(): Promise<void>;

package/dist/generate/lib-entries.js

@@ -0,0 +1,16 @@
+import { library } from "@stacksjs/config";
+import { log } from "@stacksjs/logging";
+import { hasComponents, hasFunctions } from "@stacksjs/storage";
+import { generateLibEntry } from "../helpers/lib-entries";
+export async function generateLibEntries() {
+  log.info("Generating library entry points...");
+  if (library.releaseable && hasComponents())
+    await generateLibEntry("web-components");
+  else
+    log.info("No components found. Skipping building component entry points.");
+  if (library.releaseable && hasFunctions())
+    await generateLibEntry("functions");
+  else
+    log.info("No functions found. Skipping building function entry point.");
+}
+await generateLibEntries();

package/dist/generate/pantry-file.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/generate/pantry-file.js

@@ -0,0 +1,46 @@
+import { log, runCommand } from "@stacksjs/cli";
+import { config } from "@stacksjs/config";
+const pantryFile = Bun.file(new URL("../../../../../pantry.yaml", import.meta.url));
+if (!await pantryFile.exists())
+  throw Error("pantry.yaml file not found");
+const data = Bun.YAML.parse(await pantryFile.text());
+if (data.dependencies["aws.amazon.com/cdk"] === void 0) {
+  log.info("aws.amazon.com/cdk dependency not found in pantry.yaml.");
+  if ((await runCommand("which cdk")).isErr)
+    throw Error("aws.amazon.com/cdk dependency not found in pantry.yaml. To confirm, run `which cdk`");
+}
+if (data.dependencies["aws.amazon.com/cli"] === void 0) {
+  log.info("aws.amazon.com/cli dependency not found in pantry.yaml.");
+  if ((await runCommand("which aws")).isErr)
+    throw Error("aws.amazon.com/cli dependency not found in pantry.yaml. To confirm, run `which aws`");
+}
+if (data.dependencies["bun.sh"] === void 0) {
+  log.info("bun.sh dependency not found in pantry.yaml.");
+  if ((await runCommand("which bun")).isErr)
+    throw Error("bun.sh dependency not found in pantry.yaml. To confirm, run `which bun`");
+}
+if (data.dependencies["info-zip.org/zip"] === void 0) {
+  log.info("info-zip.org/zip dependency not found in pantry.yaml.");
+  if ((await runCommand("which zip")).isErr)
+    throw Error("info-zip.org/zip dependency not found in pantry.yaml. To confirm, run `which zip`");
+}
+if (data.dependencies["info-zip.org/unzip"] === void 0) {
+  log.info("info-zip.org/unzip dependency not found in pantry.yaml.");
+  if ((await runCommand("which unzip")).isErr)
+    throw Error("info-zip.org/unzip dependency not found in pantry.yaml. To confirm, run `which unzip`");
+}
+if (data.dependencies["mailpit.axllent.org"] === void 0) {
+  log.info("mailpit.axllent.org dependency not found in pantry.yaml.");
+  if ((await runCommand("which mailpit")).isErr)
+    throw Error("mailpit.axllent.org dependency not found in pantry.yaml. To confirm, run `which mailpit`");
+}
+if (data.dependencies["redis.io"] === void 0) {
+  log.info("redis.io dependency not found in pantry.yaml.");
+  if ((await runCommand("which redis")).isErr)
+    throw Error("redis.io dependency not found in pantry.yaml. To confirm, run `which redis`");
+}
+if (config.database.default === "sqlite" && data.dependencies["sqlite.org"] === void 0) {
+  log.info("sqlite.org dependency not found in pantry.yaml.");
+  if ((await runCommand("which sqlite")).isErr)
+    throw Error("sqlite.org dependency not found in pantry.yaml. To confirm, run `which sqlite`");
+}

package/dist/generate/symlink-core.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/generate/symlink-core.js

@@ -0,0 +1,2 @@
+import { generateCoreSymlink } from "@stacksjs/actions";
+await generateCoreSymlink();

package/dist/generate/types.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/generate/types.js

@@ -0,0 +1,3 @@
+import { log } from "@stacksjs/cli";
+log.info("Generating types for ./resources/components & ./resources/function");
+log.info("Generated types saved in ./storage/framework/types/*");

package/dist/generate/vscode-custom-data.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/generate/vscode-custom-data.js

@@ -0,0 +1,9 @@
+import { log } from "@stacksjs/logging";
+import { hasComponents } from "@stacksjs/storage";
+import { generateVsCodeCustomData } from "../helpers/vscode-custom-data";
+log.info("Generating VS Code custom data...");
+if (hasComponents())
+  await generateVsCodeCustomData();
+else
+  log.info("No components found. Skipping VS Code custom data generation.");
+log.success("Generated VS Code custom data.");

package/dist/generate/web-types.d.ts

@@ -0,0 +1 @@
+

package/dist/helpers/component-meta.d.ts

@@ -0,0 +1,26 @@
+export declare function generateComponentMeta(): Promise<void>;
+/**
+ * Read an `.stx` file and return its component API surface.
+ */
+export declare function parseStxComponentMeta(componentPath: string): ComponentApi;
+export declare interface ComponentApiProp {
+  name: string
+  description: string
+  type: string
+  default: string
+  required: boolean
+}
+export declare interface ComponentApiSlot {
+  name: string
+  description: string
+}
+export declare interface ComponentApiEvent {
+  name: string
+  type: string
+  description: string
+}
+export declare interface ComponentApi {
+  props: ComponentApiProp[]
+  events: ComponentApiEvent[]
+  slots: ComponentApiSlot[]
+}

package/dist/helpers/component-meta.js

@@ -0,0 +1,295 @@
+import { frameworkPath, join, path, projectPath } from "@stacksjs/path";
+import { existsSync, globSync, mkdirSync, writeFileSync } from "@stacksjs/storage";
+import { readFileSync } from "node:fs";
+let parseMarkdownFn = null;
+async function getMarkdownParser() {
+  if (parseMarkdownFn)
+    return parseMarkdownFn;
+  try {
+    parseMarkdownFn = (await import("@stacksjs/ts-md")).parseMarkdown;
+  } catch {
+    parseMarkdownFn = (s) => s;
+  }
+  return parseMarkdownFn;
+}
+function renderDescription(raw) {
+  if (!raw)
+    return "";
+  return parseMarkdownFn ? parseMarkdownFn(raw) : raw;
+}
+export async function generateComponentMeta() {
+  await getMarkdownParser();
+  const components = globSync([
+    "components/*.stx",
+    "components/**/*.stx",
+    "resources/components/**/*.stx",
+    "storage/framework/defaults/resources/components/**/*.stx"
+  ], { cwd: projectPath(), absolute: !0 }), metaDirPath = frameworkPath("component-meta");
+  if (!existsSync(metaDirPath))
+    mkdirSync(metaDirPath, { recursive: !0 });
+  for (const componentPath of components) {
+    const componentExportName = path.parse(componentPath).name, meta = parseStxComponentMeta(componentPath), metaJsonFilePath = join(metaDirPath, `${componentExportName}.json`);
+    writeFileSync(metaJsonFilePath, JSON.stringify(meta, null, 2));
+  }
+}
+export function parseStxComponentMeta(componentPath) {
+  const source = readFileSync(componentPath, "utf8"), scriptBlock = extractFirstScriptBlock(source), templateBlock = extractTemplate(source), props = scriptBlock ? extractProps(scriptBlock) : [], events = scriptBlock ? extractEvents(scriptBlock) : [], slots = extractSlots(templateBlock);
+  return { props, events, slots };
+}
+function extractFirstScriptBlock(source) {
+  const serverMatch = /<script\b[^>]*\bserver\b[^>]*>([\s\S]*?)<\/script>/i.exec(source);
+  if (serverMatch?.[1])
+    return serverMatch[1];
+  return /<script\b[^>]*>([\s\S]*?)<\/script>/i.exec(source)?.[1] ?? null;
+}
+function extractTemplate(source) {
+  const templateMatch = /<template\b[^>]*>([\s\S]*?)<\/template>/i.exec(source);
+  if (templateMatch?.[1])
+    return templateMatch[1];
+  return source.replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, "").replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, "");
+}
+function extractProps(script) {
+  const interfaces = collectInterfaces(script), propsTypeBody = locatePropsType(script, interfaces);
+  if (!propsTypeBody)
+    return [];
+  const fields = parseTypeBody(propsTypeBody, interfaces), defaults = extractDefaults(script);
+  return fields.map((field) => {
+    return {
+      name: field.required ? field.name : `${field.name}?`,
+      description: renderDescription(field.description),
+      type: field.type,
+      default: defaults[field.name] ?? field.default ?? "unknown",
+      required: field.required
+    };
+  });
+}
+function collectInterfaces(script) {
+  const interfaces = new Map, ifaceRe = /(?:export\s+)?interface\s+([A-Z][\w$]*)\s*(?:extends\s+[\w$,\s]+)?\s*\{/g;
+  let m;
+  while ((m = ifaceRe.exec(script)) !== null) {
+    const name = m[1];
+    if (!name)
+      continue;
+    const start = m.index + m[0].length, body = sliceBalanced(script, start - 1, "{", "}");
+    if (body !== null)
+      interfaces.set(name, body);
+  }
+  const typeAliasRe = /(?:export\s+)?type\s+([A-Z][\w$]*)\s*=\s*\{/g;
+  while ((m = typeAliasRe.exec(script)) !== null) {
+    const name = m[1];
+    if (!name)
+      continue;
+    const start = m.index + m[0].length, body = sliceBalanced(script, start - 1, "{", "}");
+    if (body !== null)
+      interfaces.set(name, body);
+  }
+  return interfaces;
+}
+function locatePropsType(script, interfaces) {
+  const match = /defineProps\s*<\s*([\s\S]+?)\s*>\s*\(/.exec(script), generic = match?.[1]?.trim();
+  if (!match || !generic)
+    return null;
+  if (generic.startsWith("{")) {
+    const braceStart = script.indexOf("{", match.index);
+    return sliceBalanced(script, braceStart, "{", "}");
+  }
+  const ref = generic.replace(/[<>(].*$/, "").split("&")[0]?.trim();
+  if (!ref)
+    return null;
+  return interfaces.get(ref) ?? null;
+}
+function parseTypeBody(body, interfaces) {
+  const fields = [], statements = splitTopLevel(body, [";", `
+`]);
+  let pendingDoc = "";
+  for (const raw of statements) {
+    const stmt = raw.trim();
+    if (!stmt)
+      continue;
+    const docMatch = /^\/\*\*([\s\S]*?)\*\/\s*([\s\S]*)$/.exec(stmt);
+    if (docMatch) {
+      pendingDoc = (docMatch[1] ?? "").split(`
+`).map((l) => l.replace(/^\s*\*\s?/, "")).join(`
+`).trim();
+      const remainder = (docMatch[2] ?? "").trim();
+      if (!remainder)
+        continue;
+      const field = parseFieldLine(remainder, pendingDoc, interfaces);
+      if (field)
+        fields.push(field);
+      pendingDoc = "";
+      continue;
+    }
+    if (stmt.startsWith("//")) {
+      pendingDoc = stmt.replace(/^\/\/\s?/, "");
+      continue;
+    }
+    const field = parseFieldLine(stmt, pendingDoc, interfaces);
+    if (field)
+      fields.push(field);
+    pendingDoc = "";
+  }
+  return fields;
+}
+function parseFieldLine(line, description, _interfaces) {
+  if (/^[a-zA-Z_$][\w$]*\s*\(/.test(line.trimStart()))
+    return null;
+  const m = /^([a-zA-Z_$][\w$]*)\s*(\??)\s*:\s*([\s\S]+?)\s*[;,]?\s*$/.exec(line);
+  if (!m)
+    return null;
+  const name = m[1], optional = m[2] ?? "", type = m[3];
+  if (!name || !type)
+    return null;
+  return {
+    name,
+    type: collapseWhitespace(type),
+    required: optional !== "?",
+    description
+  };
+}
+function extractDefaults(script) {
+  const defaults = {}, destructRe = /const\s*\{\s*([\s\S]*?)\s*\}\s*=\s*(?:withDefaults\s*\(\s*)?defineProps/g;
+  let m;
+  while ((m = destructRe.exec(script)) !== null)
+    if (m[1])
+      parseDestructDefaults(m[1], defaults);
+  const withDefaultsIdx = script.indexOf("withDefaults(");
+  if (withDefaultsIdx >= 0) {
+    const afterDefine = script.indexOf("defineProps", withDefaultsIdx);
+    if (afterDefine > 0) {
+      const generic = script.indexOf(">", afterDefine), closeParen = script.indexOf(")", generic >= 0 ? generic : afterDefine);
+      if (closeParen > 0) {
+        const commaIdx = script.indexOf(",", closeParen), objStart = commaIdx >= 0 ? script.indexOf("{", commaIdx) : -1;
+        if (objStart > 0) {
+          const body = sliceBalanced(script, objStart, "{", "}");
+          if (body)
+            parseObjectDefaults(body, defaults);
+        }
+      }
+    }
+  }
+  return defaults;
+}
+function parseDestructDefaults(destructBody, out) {
+  for (const part of splitTopLevel(destructBody, [","])) {
+    const m = /^\s*([a-zA-Z_$][\w$]*)\s*=\s*([\s\S]+?)\s*$/.exec(part), key = m?.[1], value = m?.[2];
+    if (key && value)
+      out[key] = collapseWhitespace(value);
+  }
+}
+function parseObjectDefaults(objectBody, out) {
+  for (const part of splitTopLevel(objectBody, [","])) {
+    const m = /^\s*([a-zA-Z_$][\w$]*)\s*:\s*([\s\S]+?)\s*$/.exec(part.trim()), key = m?.[1], value = m?.[2];
+    if (key && value)
+      out[key] = collapseWhitespace(value);
+  }
+}
+function extractEvents(script) {
+  const m = /defineEmits\s*<\s*\{([\s\S]*?)\}\s*>\s*\(/.exec(script);
+  if (!m?.[1])
+    return [];
+  const events = [];
+  for (const part of splitTopLevel(m[1], [";", `
+`])) {
+    const trimmed = part.trim();
+    if (!trimmed)
+      continue;
+    const tuple = /^['"]?([\w-]+)['"]?\s*:\s*\[(.*?)\]\s*$/.exec(trimmed);
+    if (tuple) {
+      const name = tuple[1];
+      if (!name)
+        continue;
+      events.push({ name, type: tuple[2]?.trim() || "void", description: "" });
+      continue;
+    }
+    const fn = /^([a-zA-Z_$][\w$]*)\s*\(([\s\S]*?)\)\s*:\s*([\s\S]+)$/.exec(trimmed);
+    if (fn) {
+      const name = fn[1];
+      if (!name)
+        continue;
+      events.push({ name, type: fn[2]?.trim() || "void", description: "" });
+    }
+  }
+  return events;
+}
+function extractSlots(template) {
+  const slots = [], seen = new Set, slotRe = /<slot\b([^>]*)>/g;
+  let m;
+  while ((m = slotRe.exec(template)) !== null) {
+    const attrs = m[1] ?? "", name = /\bname\s*=\s*["']([^"']+)["']/.exec(attrs)?.[1] ?? "default";
+    if (seen.has(name))
+      continue;
+    seen.add(name);
+    slots.push({ name, description: "" });
+  }
+  return slots;
+}
+function sliceBalanced(source, openIdx, open, close) {
+  if (source[openIdx] !== open)
+    return null;
+  let depth = 0, i = openIdx, inString = null;
+  while (i < source.length) {
+    const ch = source[i];
+    if (ch === void 0)
+      break;
+    if (inString) {
+      if (ch === "\\") {
+        i += 2;
+        continue;
+      }
+      if (ch === inString)
+        inString = null;
+      i++;
+      continue;
+    }
+    if (ch === '"' || ch === "'" || ch === "`") {
+      inString = ch;
+      i++;
+      continue;
+    }
+    if (ch === open)
+      depth++;
+    else if (ch === close) {
+      depth--;
+      if (depth === 0)
+        return source.slice(openIdx + 1, i);
+    }
+    i++;
+  }
+  return null;
+}
+function splitTopLevel(source, separators) {
+  const out = [], sepSet = new Set(separators);
+  let depth = 0, inString = null, start = 0;
+  for (let i = 0;i < source.length; i++) {
+    const ch = source[i];
+    if (ch === void 0)
+      break;
+    if (inString) {
+      if (ch === "\\") {
+        i++;
+        continue;
+      }
+      if (ch === inString)
+        inString = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'" || ch === "`") {
+      inString = ch;
+      continue;
+    }
+    if (ch === "{" || ch === "[" || ch === "(" || ch === "<")
+      depth++;
+    else if (ch === "}" || ch === "]" || ch === ")" || ch === ">")
+      depth--;
+    else if (depth === 0 && sepSet.has(ch)) {
+      out.push(source.slice(start, i));
+      start = i + 1;
+    }
+  }
+  out.push(source.slice(start));
+  return out;
+}
+function collapseWhitespace(s) {
+  return s.replace(/\s+/g, " ").trim();
+}

package/dist/helpers/index.d.ts

@@ -0,0 +1,4 @@
+// export * from './component-meta'
+// export * from './lib-entries'
+// export * from './package-json'
+export * from './utils';

package/dist/helpers/index.js

@@ -0,0 +1 @@
+export * from "./utils";

package/dist/helpers/lib-entries.d.ts

@@ -0,0 +1,12 @@
+import type { LibraryType } from '@stacksjs/path';
+/**
+ * Based on the config values, this method
+ * will generate the library entry points.
+ *
+ * @param type LibraryType
+ */
+export declare function generateLibEntry(type: LibraryType): Promise<void>;
+export declare function createLibraryEntryPoint(type: LibraryType): Promise<void>;
+export declare function createWebComponentLibraryEntryPoint(type?: LibraryType): Promise<void>;
+export declare function createFunctionLibraryEntryPoint(type?: LibraryType): Promise<void>;
+export declare function generateEntryPointData(type: LibraryType): string;

package/dist/helpers/lib-entries.js

@@ -0,0 +1,73 @@
+import process from "node:process";
+import { log } from "@stacksjs/logging";
+import { componentsPath, functionsPath, libraryEntryPath } from "@stacksjs/path";
+import { writeTextFile } from "@stacksjs/storage";
+import { kebabCase } from "@stacksjs/strings";
+import { ExitCode } from "@stacksjs/types";
+import { determineResetPreset } from "@stacksjs/utils";
+import library from "~/config/library";
+export async function generateLibEntry(type) {
+  await createLibraryEntryPoint(type);
+}
+export async function createLibraryEntryPoint(type) {
+  if (type === "web-components")
+    await createWebComponentLibraryEntryPoint();
+  if (type === "functions")
+    await createFunctionLibraryEntryPoint();
+}
+export async function createWebComponentLibraryEntryPoint(type = "web-components") {
+  log.info("Ensuring Web Component Library Entry Point...");
+  await writeTextFile({
+    path: libraryEntryPath(type),
+    data: generateEntryPointData(type)
+  }).catch((err) => {
+    log.error("There was an error generating the Web Component library entry point", err);
+    process.exit(ExitCode.FatalError);
+  });
+  log.success("Created Web Component Library Entry Point");
+}
+export async function createFunctionLibraryEntryPoint(type = "functions") {
+  log.info("Ensuring Function Library Entry Point...");
+  await writeTextFile({
+    path: libraryEntryPath(type),
+    data: generateEntryPointData(type)
+  }).catch((err) => {
+    log.error("There was an error generating Function Library Entry Point", err);
+    process.exit(ExitCode.FatalError);
+  });
+  log.success("Created Functions Library Entry Point");
+}
+export function generateEntryPointData(type) {
+  let arr = [];
+  if (type === "functions") {
+    if (!library.functions?.files) {
+      log.error(Error("There are no functions defined to be built. Please check your config/library.ts file for potential adjustments"));
+      process.exit(ExitCode.FatalError);
+    }
+    for (const fx of library.functions.files)
+      if (Array.isArray(fx))
+        arr.push(`export * as ${fx[1]} from '${functionsPath(fx[0])}'`);
+      else
+        arr.push(`export * from '${functionsPath(fx)}'`);
+    return arr.join(`\r
+`);
+  }
+  arr = determineResetPreset();
+  const imports = [...arr, "import { defineCustomElement } from 'vue'"], declarations = [], definitions = [];
+  if (!library.webComponents?.tags) {
+    log.error(Error("There are no components defined to be built. Please check your config/library.ts file for potential adjustments"));
+    process.exit(ExitCode.FatalError);
+  }
+  for (const component of library.webComponents.tags.map((tag) => tag.name))
+    if (Array.isArray(component)) {
+      imports.push(`import ${component[1]} from '${componentsPath(component[0])}.vue'`);
+      declarations.push(`const ${component[1]}CustomElement = defineCustomElement(${component[1]})`);
+      definitions.push(`customElements.define('${kebabCase(component[1])}', ${component[1]}CustomElement)`);
+    } else {
+      imports.push(`import ${component} from '${componentsPath(component)}.vue'`);
+      declarations.push(`const ${component}CustomElement = defineCustomElement(${component})`);
+      definitions.push(`customElements.define('${kebabCase(component)}', ${component}CustomElement)`);
+    }
+  return [...imports, ...declarations, ...definitions].join(`\r
+`);
+}