@stacksjs/actions 0.57.3 → 0.58.19

package/README.md

@@ -14,7 +14,7 @@ This package contains the Stacks Actions.
 ## 🤖 Usage
 
 ```bash
-pnpm i -D @stacksjs/actions
+bun install -d @stacksjs/actions
 ```
 
 Now, you can use it in your project:
@@ -30,7 +30,7 @@ Learn more in the docs.
 ## 🧪 Testing
 
 ```bash
-pnpm test
+bun test
 ```
 
 ## 📈 Changelog
@@ -49,10 +49,10 @@ For help, discussion about best practices, or any other conversation that would
 
 For casual chit-chat with others using this package:
 
-[Join the Stacks Discord Server](https://discord.ow3.org)
+[Join the Stacks Discord Server](https://discord.gg/stacksjs)
 
 ## 📄 License
 
 The MIT License (MIT). Please see [LICENSE](https://github.com/stacksjs/stacks/tree/main/LICENSE.md) for more information.
 
-Made with ❤️
+Made with 💙

package/dist/src/add.js

@@ -0,0 +1,29 @@
+// @bun
+// src/add.ts
+import {installPackage} from "@stacksjs/cli";
+async function invoke(options) {
+  if (options?.table)
+    await addTable();
+  if (options?.calendar)
+    await addCalendar();
+}
+async function add(options) {
+  return invoke(options);
+}
+async function addTable() {
+  await installPackage("@stacksjs/table");
+}
+async function addCalendar() {
+  await installPackage("@stacksjs/calendar");
+}
+async function installPackages(names) {
+  for (const name of names)
+    await installPackage(name);
+}
+export {
+  invoke,
+  installPackages,
+  addTable,
+  addCalendar,
+  add
+};

package/dist/src/build/component-libs.js

@@ -0,0 +1,6 @@
+// @bun
+// src/build/component-libs.ts
+import {frameworkPath} from "@stacksjs/path";
+import {runCommand} from "@stacksjs/cli";
+import {NpmScript} from "@stacksjs/enums";
+await runCommand(NpmScript.BuildComponents, { cwd: frameworkPath(), verbose: true });

package/dist/src/build/core.js

@@ -0,0 +1,25 @@
+// @bun
+// src/build/core.ts
+import process from "process";
+import {glob} from "@stacksjs/storage";
+import {corePath} from "@stacksjs/path";
+import {ExitCode} from "@stacksjs/types";
+import {dim, italic, log, runCommand} from "@stacksjs/cli";
+log.info("Building core packages");
+var dirs = await glob([corePath("*")], { onlyDirectories: true });
+if (dirs.length === 0) {
+  log.info("No core packages found");
+  process.exit(ExitCode.FatalError);
+}
+dirs.forEach(async (folder) => {
+  log.info("\uD83C\uDFD7\uFE0F  Building...");
+  log.info(`\uD83D\uDCE6 ${italic(dim(folder))}`);
+  const result = await runCommand("bun --bun run build", {
+    cwd: folder
+  });
+  if (result.isErr()) {
+    log.error(`Failed to build ${italic(folder)}`);
+    process.exit(ExitCode.FatalError);
+  }
+  log.success("\u2705 Build complete");
+});

package/dist/src/build/stacks.js

@@ -0,0 +1,8 @@
+// @bun
+// src/build/stacks.ts
+import {frameworkPath} from "@stacksjs/path";
+import {runCommands} from "@stacksjs/cli";
+await runCommands([
+  "bun build:cli",
+  "bun build:core"
+], { verbose: true, cwd: frameworkPath() });

package/dist/src/build.js

@@ -0,0 +1,226 @@
+// @bun
+// src/helpers/utils.ts
+import * as storage from "@stacksjs/storage";
+import {italic, runCommand, runCommands, underline} from "@stacksjs/cli";
+import {log} from "@stacksjs/logging";
+import * as p from "@stacksjs/path";
+import {err, handleError} from "@stacksjs/error-handling";
+var parseOptions = function(options) {
+  if (!options)
+    return "";
+  const parsedOptions = Object.entries(options).map(([key, value]) => {
+    if (key.length === 1)
+      return `-${key}=${value}`;
+    if (typeof value === "boolean" && value)
+      return `--${key}`;
+    return `--${key}=${typeof value === "string" && value.includes(" ") ? `"${value}"` : value}`;
+  });
+  return parsedOptions.filter(Boolean).join(" ").replace("----=", "");
+};
+async function runAction(action, options) {
+  if (!hasAction(action))
+    return err(handleError(`The specified action "${action}" does not exist`));
+  const opts = parseOptions(options);
+  const path = p.relativeActionsPath(`${action}.ts`);
+  const cmd = `bun --bun ${`${path} ${opts}`}`;
+  const o = {
+    cwd: options?.cwd || p.projectPath(),
+    ...options
+  };
+  if (options?.verbose) {
+    log.debug("Running cmd:", underline(italic(cmd)));
+    log.debug("Running action:", underline(italic(`./actions/${action}.ts`)));
+    log.debug("with action options of:", o);
+  }
+  return await runCommand(cmd, o);
+}
+async function runActions(actions, options) {
+  if (!actions.length)
+    return err("No actions were specified");
+  for (const action of actions) {
+    if (!hasAction(action))
+      return err(`The specified action "${action}" does not exist`);
+  }
+  const commands = actions.map((action) => `bun --bun ${p.relativeActionsPath(`${action}.ts`)}`);
+  return await runCommands(commands, options);
+}
+function hasAction(action) {
+  if (storage.isFile(p.functionsPath(`actions/${action}.ts`)))
+    return true;
+  return storage.isFile(p.actionsPath(`${action}.ts`));
+}
+// src/generate/index.ts
+import process from "process";
+import {log as log2} from "@stacksjs/logging";
+import {Action, NpmScript} from "@stacksjs/enums";
+import {runNpmScript} from "@stacksjs/utils";
+import {projectPath as projectPath2} from "@stacksjs/path";
+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(options);
+  else if (options?.ideHelpers)
+    await generateIdeHelpers(options);
+  else if (options?.vueCompatibility)
+    await generateVueCompat(options);
+  else if (options?.componentMeta)
+    await generateComponentMeta(options);
+}
+function generate(options) {
+  return invoke(options);
+}
+async function generateLibEntries(options) {
+  const result = await runAction(Action.GenerateLibraryEntries, {
+    ...options,
+    verbose: true,
+    cwd: projectPath2()
+  });
+  if (result.isErr()) {
+    log2.error("There was an error generating your library entry points", result.error);
+    process.exit();
+  }
+  log2.success("Library entry points generated successfully");
+}
+async function generateVueCompat(options) {
+  const result = await runNpmScript(NpmScript.GenerateVueCompat, options);
+  if (result.isErr()) {
+    log2.error("There was an error generating Vue 2 compatibility.", result.error);
+    process.exit();
+  }
+  log2.success("Libraries are now Vue 2 & 3 compatible");
+}
+async function generateWebTypes(options) {
+  const result = await runNpmScript(NpmScript.GenerateWebTypes, options);
+  if (result.isErr()) {
+    log2.error("There was an error generating the web-types.json file.", result.error);
+    process.exit();
+  }
+  log2.success("Successfully generated the web-types.json file");
+}
+async function generateVsCodeCustomData(options) {
+  const result = await runNpmScript(NpmScript.GenerateVsCodeCustomData, options);
+  if (result.isErr()) {
+    log2.error("There was an error generating the custom-elements.json file.", result.error);
+    process.exit();
+  }
+  await runAction(Action.LintFix, { verbose: true });
+  log2.success("Successfully generated the custom-elements.json file");
+}
+async function generateIdeHelpers(options) {
+  const result = await runNpmScript(NpmScript.GenerateIdeHelpers, options);
+  if (result.isErr()) {
+    log2.error("There was an error generating IDE helpers.", result.error);
+    process.exit();
+  }
+  await runAction(Action.LintFix, { verbose: true });
+  log2.success("Successfully generated IDE helpers");
+}
+async function generateComponentMeta(options) {
+  const result = await runNpmScript(NpmScript.GenerateComponentMeta, options);
+  if (result.isErr()) {
+    log2.error("There was an error generating your component meta information.", result.error);
+    process.exit();
+  }
+  await runAction(Action.LintFix, { verbose: true });
+  log2.success("Successfully generated component meta information");
+}
+async function generateTypes(options) {
+  const result = await runNpmScript(NpmScript.GenerateTypes, options);
+  if (result.isErr()) {
+    log2.error("There was an error generating your types.", result.error);
+    process.exit();
+  }
+  log2.success("Types were generated successfully");
+}
+function generateMigrations() {
+  log2.success("Successfully updated migrations");
+}
+function generatePkgxConfig() {
+  log2.success("Successfully generated `./pkgx.yaml` based on your configs");
+}
+async function generateSeeder() {
+}
+
+// src/build.ts
+import {log as log3} from "@stacksjs/logging";
+import {hasComponents, hasFunctions} from "@stacksjs/storage";
+import {runNpmScript as runNpmScript2} from "@stacksjs/utils";
+import {NpmScript as NpmScript2} from "@stacksjs/enums";
+async function invoke2(options) {
+  if (options.components)
+    await componentLibraries(options);
+  else if (options.vueComponents)
+    await vueComponentLibrary(options);
+  else if (options.webComponents || options.elements)
+    await webComponentLibrary(options);
+  else if (options.functions)
+    await functionsLibrary(options);
+  else if (options.docs)
+    await docs(options);
+  else if (options.stacks)
+    await stacks(options);
+  await generateTypes();
+}
+async function build(options) {
+  return invoke2(options);
+}
+async function componentLibraries(options) {
+  await runNpmScript2(NpmScript2.GenerateEntries, options);
+  await vueComponentLibrary(options);
+  await webComponentLibrary(options);
+}
+async function vueComponentLibrary(options) {
+  if (hasComponents()) {
+    log3.info("Building your component library...");
+    await runNpmScript2(NpmScript2.BuildComponents, options);
+    log3.success("Your component library was built successfully");
+  } else {
+    log3.warn("No components found.");
+    log3.info("Before you can build components,");
+    log3.info("you need to have created some in the ./components folder.");
+  }
+}
+async function webComponentLibrary(options) {
+  log3.info("Building your component library for production use & npm/CDN distribution...");
+  if (hasComponents()) {
+    await runNpmScript2(NpmScript2.BuildWebComponents, options);
+    log3.success("Your Web Component library was built successfully");
+  } else {
+    log3.info("No components found.");
+  }
+}
+async function docs(options) {
+  log3.info("Building the documentation site...");
+  await runNpmScript2(NpmScript2.BuildDocs, options);
+  log3.success("Docs built successfully");
+}
+async function stacks(options) {
+  log3.info("Building the Stacks Framework...");
+  await runNpmScript2(NpmScript2.BuildStacks, options);
+  log3.success("Stacks built successfully");
+}
+async function functionsLibrary(options) {
+  if (hasFunctions()) {
+    log3.info("Building your functions library for production usages...");
+    log3.info("Production usages include: manual npm distribution and/or CDN distribution");
+    await runNpmScript2(NpmScript2.BuildFunctions, options);
+    log3.success("Functions library built successfully");
+  } else {
+    log3.info("No functions found");
+  }
+}
+export {
+  webComponentLibrary,
+  vueComponentLibrary,
+  stacks,
+  invoke2 as invoke,
+  functionsLibrary,
+  docs,
+  componentLibraries,
+  build
+};

package/dist/src/bump.js

@@ -0,0 +1,8 @@
+// @bun
+// src/bump.ts
+import {runCommand} from "@stacksjs/cli";
+import {path as p} from "@stacksjs/path";
+await runCommand("buddy changelog --quiet", {
+  cwd: p.projectPath()
+});
+await runCommand("bunx bumpp ./package.json ./core/**/package.json ./ide/vscode/package.json --all", { cwd: p.frameworkPath(), stdin: "inherit" });

package/dist/src/changelog.js

@@ -0,0 +1,9 @@
+// @bun
+// src/changelog.ts
+import {execSync, runCommand} from "@stacksjs/cli";
+import {projectPath} from "@stacksjs/path";
+var fromRevision = await execSync("git describe --abbrev=0 --tags HEAD^");
+var toRevision = await execSync("git describe");
+await runCommand(`bunx changelogen --output CHANGELOG.md --from ${fromRevision} --to ${toRevision}`, {
+  cwd: projectPath()
+});

package/dist/src/clean.js

@@ -0,0 +1,6 @@
+// @bun
+// src/clean.ts
+import {log} from "@stacksjs/logging";
+import {clean} from "@stacksjs/utils";
+log.info("Running clean command...");
+await clean();

package/dist/src/commit.js

@@ -0,0 +1,17 @@
+// @bun
+// src/commit.ts
+import {log} from "@stacksjs/logging";
+import {runNpmScript} from "@stacksjs/utils";
+import {NpmScript} from "@stacksjs/enums";
+async function invoke(options) {
+  log.info("Committing...");
+  await runNpmScript(NpmScript.Commit, options);
+  log.success("Committed");
+}
+async function commit(options) {
+  return invoke(options);
+}
+export {
+  invoke,
+  commit
+};

package/dist/{copy-types.mjs → src/copy-types.js}

@@ -1,7 +1,10 @@
-#!/usr/bin/env node
-import { frameworkPath } from "@stacksjs/path";
-import { copyFolder } from "@stacksjs/storage";
-const destinations = [
+#!/usr/bin/env bun
+// @bun
+
+// src/copy-types.ts
+import {frameworkPath} from "@stacksjs/path";
+import {copyFolder} from "@stacksjs/storage";
+var destinations = [
   [frameworkPath("dist/types/components"), frameworkPath("components/vue/dist/types")],
   [frameworkPath("dist/types/components"), frameworkPath("components/web/dist/types")],
   [frameworkPath("dist/types/functions"), frameworkPath("functions/dist/types")]

package/dist/src/database/seed.js

@@ -0,0 +1,4 @@
+// @bun
+// src/database/seed.ts
+import {seed} from "@stacksjs/database";
+await seed();

package/dist/src/deploy/index.js

@@ -0,0 +1,31 @@
+// @bun
+// src/deploy/index.ts
+import process from "process";
+import {log, runCommand} from "@stacksjs/cli";
+import {config as config2} from "@stacksjs/config";
+import {path as p} from "@stacksjs/path";
+import {storage as storage2} from "@stacksjs/storage";
+await runCommand("bun run build", {
+  cwd: p.frameworkPath()
+});
+if (storage2.hasFiles(p.projectPath("docs"))) {
+  await runCommand("bun run build", {
+    cwd: p.frameworkPath("docs")
+  });
+}
+if (config2.app.docMode !== true) {
+  await runCommand("bun run build", {
+    cwd: p.frameworkPath("views")
+  });
+}
+await runCommand("bun zip/api.ts", {
+  cwd: p.actionsPath()
+});
+await runCommand("bun zip.ts", {
+  cwd: p.cloudPath()
+});
+log.info("Preparing deployment...");
+var profile = process.env.AWS_PROFILE || "stacks";
+await runCommand(`bunx cdk deploy --require-approval never --profile="${profile}"`, {
+  cwd: p.cloudPath()
+});

package/dist/src/dev/components.js

@@ -0,0 +1,11 @@
+// @bun
+// src/dev/components.ts
+import {frameworkPath, vitePath} from "@stacksjs/path";
+import {parseOptions, runCommand} from "@stacksjs/cli";
+var options = parseOptions();
+if (options.verbose)
+  console.log("dev components options", options);
+await runCommand(`bunx --bun vite --config ${vitePath("src/components.ts")}`, {
+  ...options,
+  cwd: frameworkPath()
+});

package/dist/src/dev/docs.js

@@ -0,0 +1,7 @@
+// @bun
+// src/dev/docs.ts
+import {runCommand} from "@stacksjs/cli";
+import {frameworkPath} from "@stacksjs/path";
+await runCommand("bun run dev", {
+  cwd: frameworkPath("docs")
+});

package/dist/src/dev/index.js

@@ -0,0 +1,90 @@
+// @bun
+// src/helpers/utils.ts
+import * as storage from "@stacksjs/storage";
+import {italic, runCommand, runCommands, underline} from "@stacksjs/cli";
+import {log} from "@stacksjs/logging";
+import * as p from "@stacksjs/path";
+import {err, handleError} from "@stacksjs/error-handling";
+var parseOptions = function(options) {
+  if (!options)
+    return "";
+  const parsedOptions = Object.entries(options).map(([key, value]) => {
+    if (key.length === 1)
+      return `-${key}=${value}`;
+    if (typeof value === "boolean" && value)
+      return `--${key}`;
+    return `--${key}=${typeof value === "string" && value.includes(" ") ? `"${value}"` : value}`;
+  });
+  return parsedOptions.filter(Boolean).join(" ").replace("----=", "");
+};
+async function runAction(action, options) {
+  if (!hasAction(action))
+    return err(handleError(`The specified action "${action}" does not exist`));
+  const opts = parseOptions(options);
+  const path = p.relativeActionsPath(`${action}.ts`);
+  const cmd = `bun --bun ${`${path} ${opts}`}`;
+  const o = {
+    cwd: options?.cwd || p.projectPath(),
+    ...options
+  };
+  if (options?.verbose) {
+    log.debug("Running cmd:", underline(italic(cmd)));
+    log.debug("Running action:", underline(italic(`./actions/${action}.ts`)));
+    log.debug("with action options of:", o);
+  }
+  return await runCommand(cmd, o);
+}
+async function runActions(actions, options) {
+  if (!actions.length)
+    return err("No actions were specified");
+  for (const action of actions) {
+    if (!hasAction(action))
+      return err(`The specified action "${action}" does not exist`);
+  }
+  const commands = actions.map((action) => `bun --bun ${p.relativeActionsPath(`${action}.ts`)}`);
+  return await runCommands(commands, options);
+}
+function hasAction(action) {
+  if (storage.isFile(p.functionsPath(`actions/${action}.ts`)))
+    return true;
+  return storage.isFile(p.actionsPath(`${action}.ts`));
+}
+// src/dev/index.ts
+import {log as log2} from "@stacksjs/logging";
+import {Action} from "@stacksjs/enums";
+async function runDevServer(options) {
+  log2.info("Starting your Frontend Engine...");
+  await runAction(Action.Dev, options);
+}
+async function runFrontendDevServer(options) {
+  log2.info("Starting your UI Engine...");
+  await runAction(Action.Dev, options);
+}
+async function runBackendDevServer(options) {
+  runApiDevServer(options);
+}
+async function runApiDevServer(options) {
+  log2.info("Starting your API...");
+  await runAction(Action.DevApi, options);
+}
+async function runComponentsDevServer(options) {
+  log2.info("Starting your Library Engine...");
+  await runAction(Action.DevComponents, options);
+}
+async function runDesktopDevServer(options) {
+  log2.info("Starting your Desktop Engine...");
+  await runAction(Action.DevDesktop, options);
+}
+async function runDocsDevServer(options) {
+  log2.info("Starting your Docs Engine...");
+  await runAction(Action.DevDocs, options);
+}
+export {
+  runFrontendDevServer,
+  runDocsDevServer,
+  runDevServer,
+  runDesktopDevServer,
+  runComponentsDevServer,
+  runBackendDevServer,
+  runApiDevServer
+};

package/dist/{examples.mjs → src/examples.js}

@@ -1,8 +1,12 @@
-import { log } from "@stacksjs/logging";
-import { hasComponents } from "@stacksjs/storage";
-import { runNpmScript } from "@stacksjs/utils";
-import { ExitCode, NpmScript } from "@stacksjs/types";
-export async function invoke(options) {
+// @bun
+// src/examples.ts
+import process from "process";
+import {log} from "@stacksjs/logging";
+import {hasComponents} from "@stacksjs/storage";
+import {runNpmScript} from "@stacksjs/utils";
+import {ExitCode} from "@stacksjs/types";
+import {NpmScript} from "@stacksjs/enums";
+async function invoke(options) {
   if (options.components || options.vue)
     await componentExample(options);
   else if (options.webComponents || options.elements)
@@ -10,10 +14,10 @@ export async function invoke(options) {
   else
     log.error("An unsupported option was used. Please try again, check the documentation & report the issue, if needed.");
 }
-export async function examples(options) {
+async function examples(options) {
   return invoke(options);
 }
-export async function componentExample(options) {
+async function componentExample(options) {
   if (hasComponents()) {
     await runNpmScript(NpmScript.ExampleVue, options);
     log.success("Your component library was built successfully");
@@ -21,7 +25,7 @@ export async function componentExample(options) {
     log.info("No components found.");
   }
 }
-export async function webComponentExample(options) {
+async function webComponentExample(options) {
   if (hasComponents()) {
     log.info("Building your Web Component library...");
     await runNpmScript(NpmScript.BuildWebComponents, options);
@@ -31,3 +35,9 @@ export async function webComponentExample(options) {
     process.exit(ExitCode.FatalError);
   }
 }
+export {
+  webComponentExample,
+  invoke,
+  examples,
+  componentExample
+};

package/dist/src/fresh.js

@@ -0,0 +1,18 @@
+// @bun
+// src/fresh.ts
+import process from "process";
+import {ExitCode} from "@stacksjs/types";
+import {runCommand} from "@stacksjs/cli";
+import {logger} from "@stacksjs/logging";
+import {projectPath} from "@stacksjs/path";
+import {cleanProject} from "@stacksjs/utils";
+logger.log("Cleaning project...");
+await cleanProject();
+logger.log("Installing dependencies...");
+var result = await runCommand("bun install", {
+  cwd: projectPath()
+});
+if (result.isErr()) {
+  handleError(result.error);
+  process.exit(ExitCode.FatalError);
+}

package/dist/src/generate/component-meta.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/helpers/component-meta.ts
+import {frameworkPath, join, parse, projectPath} from "@stacksjs/path";
+import {existsSync, glob, mkdirSync, writeFileSync} from "@stacksjs/storage";
+import MarkdownIt from "markdown-it";
+import {createComponentMetaChecker} from "vue-component-meta";
+function generateComponentMeta() {
+  const md = new MarkdownIt;
+  const checkerOptions = {
+    forceUseTs: true,
+    schema: { ignore: ["MyIgnoredNestedProps"] },
+    printer: { newLine: 1 }
+  };
+  const tsconfigChecker = createComponentMetaChecker(projectPath("tsconfig.json"), checkerOptions);
+  const filterMeta = (meta) => {
+    const props = [];
+    meta.props.forEach((prop) => {
+      if (prop?.global)
+        return;
+      const { name, description, required, type, default: defaultValue } = prop;
+      props.push({
+        name: `${name}${required ? "" : "?"}`,
+        description: md.render(description),
+        type,
+        default: defaultValue || "unknown"
+      });
+    });
+    return {
+      props,
+      events: meta.events,
+      slots: meta.slots
+    };
+  };
+  const components = glob.sync(["components/*.stx", "components/**/*.stx"], {
+    cwd: projectPath(),
+    absolute: true
+  });
+  components.forEach((componentPath) => {
+    const componentExportName = parse(componentPath).name;
+    const meta = filterMeta(tsconfigChecker.getComponentMeta(componentPath, componentExportName));
+    const metaDirPath = frameworkPath("component-meta");
+    if (!existsSync(metaDirPath))
+      mkdirSync(metaDirPath);
+    const metaJsonFilePath = join(metaDirPath, `${componentExportName}.json`);
+    writeFileSync(metaJsonFilePath, JSON.stringify(meta, null, 4));
+  });
+}
+
+// src/generate/component-meta.ts
+import {log} from "@stacksjs/logging";
+import {hasComponents} from "@stacksjs/storage";
+if (hasComponents())
+  generateComponentMeta();
+else
+  log.info("No components found. Skipping component meta generation.");