@stacksjs/actions 0.59.11 → 0.61.0

package/dist/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/build/component-libs.js

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

package/dist/build/core.js

@@ -0,0 +1,21 @@
+// @bun
+// src/build/core.ts
+import process from "process";
+import {dim, italic, log} from "@stacksjs/cli";
+import {corePath} from "@stacksjs/path";
+import {glob} from "@stacksjs/storage";
+import {ExitCode} from "@stacksjs/types";
+var {$ } = globalThis.Bun;
+log.info("Building core packages");
+var dirs = (await glob([corePath("*")], { onlyDirectories: true })).sort();
+if (dirs.length === 0) {
+  log.info("No core packages found");
+  process.exit(ExitCode.FatalError);
+}
+for (const folder of dirs) {
+  log.info(`\uD83C\uDFD7\uFE0F  Building ${italic(dim(folder))}`);
+  $.cwd(folder);
+  await $`bun run build`;
+  log.success(`${italic(dim(folder))} built`);
+  console.log(``);
+}

package/dist/build/stacks.js

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

package/dist/build.js

@@ -0,0 +1,317 @@
+// @bun
+// src/helpers/utils.ts
+import {buddyOptions, runCommand, runCommands} from "@stacksjs/cli";
+import {err} from "@stacksjs/error-handling";
+import {log} from "@stacksjs/logging";
+import * as p from "@stacksjs/path";
+import {glob} from "@stacksjs/storage";
+var {Glob } = globalThis.Bun;
+async function runAction(action, options) {
+  const glob2 = new Glob("**/*.ts");
+  const scanOptions = { cwd: p.userActionsPath(), onlyFiles: true };
+  for await (const file of glob2.scan(scanOptions)) {
+    log.debug("file", file);
+    if (file === `${action}.ts` || file.endsWith(`${action}.ts`))
+      return (await import(p.userActionsPath(file))).default.handle();
+    const a = await import(p.userActionsPath(file));
+    if (a.name === action)
+      return await a.handle();
+  }
+  const opts = buddyOptions();
+  const path = p.relativeActionsPath(`src/${action}.ts`);
+  const cmd = `bun --bun ${path} ${opts}`.trimEnd();
+  const optionsWithCwd = {
+    cwd: options?.cwd || p.projectPath(),
+    ...options
+  };
+  log.debug("runAction:", cmd);
+  log.debug("action options:", optionsWithCwd);
+  return await runCommand(cmd, optionsWithCwd);
+}
+async function runActions(actions, options) {
+  log.debug("runActions:", actions, options);
+  if (!actions.length)
+    return err("No actions were specified");
+  for (const action of actions) {
+    log.debug(`running action "${action}"`);
+    if (!hasAction(action))
+      return err(`The specified action "${action}" does not exist`);
+  }
+  const opts = buddyOptions();
+  const o = {
+    cwd: options?.cwd || p.projectPath(),
+    ...options
+  };
+  const commands = actions.map((action) => `bun --bun ${p.relativeActionsPath(`src/${action}.ts`)} ${opts}`);
+  log.debug("commands:", commands);
+  return await runCommands(commands, o);
+}
+function hasAction(action) {
+  const userActionPatterns = [
+    `${action}.ts`,
+    `${action}`,
+    `Dashboard/${action}.ts`,
+    `Dashboard/${action}`,
+    `Buddy/${action}.ts`,
+    `Buddy/${action}`
+  ];
+  const actionPatterns = [`src/${action}.ts`, `src/${action}`, `${action}.ts`, `${action}`];
+  const userActionFiles = glob.sync(userActionPatterns.map((pattern) => p.userActionsPath(pattern)));
+  const actionFiles = glob.sync(actionPatterns.map((pattern) => p.actionsPath(pattern)));
+  return userActionFiles.length > 0 || actionFiles.length > 0;
+}
+
+// src/helpers/vscode-custom-data.ts
+import {log as log2} from "@stacksjs/logging";
+import {customElementsDataPath} from "@stacksjs/path";
+import {writeTextFile} from "@stacksjs/storage";
+
+// ../../../../config/library.ts
+var library_default = {
+  name: "hello-world",
+  owner: "@stacksjs",
+  repository: "stacksjs/stacks",
+  license: "MIT",
+  author: "Chris Breuer",
+  contributors: ["Chris Breuer <chris@stacksjs.org>"],
+  defaultLanguage: "en",
+  releaseable: true,
+  vueComponents: {
+    name: "hello-world-vue",
+    description: "Your Vue component library description",
+    keywords: ["component", "library", "vue", "vite", "typescript", "javascript"],
+    tags: [
+      {
+        name: ["HelloWorld", "AppHelloWorld"],
+        description: "The Hello World custom element, built via this framework.",
+        attributes: [
+          {
+            name: "greeting",
+            description: "The greeting."
+          }
+        ]
+      }
+    ]
+  },
+  webComponents: {
+    name: "hello-world-elements",
+    description: "Your framework agnostic web component library description.",
+    keywords: ["custom-elements", "web-components", "library", "framework-agnostic", "typescript", "javascript"],
+    tags: [
+      {
+        name: ["HelloWorld", "AppHelloWorld"],
+        description: "The Hello World custom element, built via this framework.",
+        attributes: [
+          {
+            name: "greeting",
+            description: "The greeting."
+          }
+        ]
+      }
+    ]
+  },
+  functions: {
+    name: "hello-world-fx",
+    description: "Your function library description.",
+    keywords: ["functions", "composables", "library", "typescript", "javascript"],
+    shouldGenerateSourcemap: false,
+    files: ["counter", "dark"]
+  }
+};
+
+// src/helpers/vscode-custom-data.ts
+async function generateVsCodeCustomData() {
+  try {
+    log2.info("Generating custom-elements.json...");
+    await writeTextFile({
+      path: customElementsDataPath(),
+      data: generateComponentInfoData()
+    });
+    log2.success("Generated custom-elements.json for IDEs.");
+  } catch (err2) {
+    log2.error("There was an error generating the custom-elements.json file.", err2);
+  }
+}
+async function generateWebTypes() {
+  log2.info("Generating web-types.json...");
+  log2.info("This feature is not yet implemented.");
+}
+var generateComponentInfoData = function() {
+  const componentsData = JSON.stringify(library_default.vueComponents?.tags);
+  return `{
+  "version": 1.1,
+  "tags": ${componentsData}
+}
+`;
+};
+
+// src/generate/index.ts
+import process from "process";
+import {runCommand as runCommand2} from "@stacksjs/cli";
+import {Action, NpmScript} from "@stacksjs/enums";
+import {log as log3} from "@stacksjs/logging";
+import {frameworkPath, projectPath as projectPath2} from "@stacksjs/path";
+import {runNpmScript} from "@stacksjs/utils";
+async function invoke(options) {
+  if (options?.types)
+    await generateTypes(options);
+  else if (options?.entries)
+    await generateLibEntries(options);
+  else if (options?.webTypes)
+    await generateWebTypes2(options);
+  else if (options?.customData)
+    await generateVsCodeCustomData2(options);
+  else if (options?.ideHelpers)
+    await generateIdeHelpers(options);
+  else if (options?.componentMeta)
+    await generateComponentMeta(options);
+  else if (options?.coreSymlink)
+    await generateCoreSymlink();
+}
+function generate(options) {
+  return invoke(options);
+}
+async function generateLibEntries(options) {
+  const result = await runAction(Action.GenerateLibraryEntries, {
+    ...options,
+    cwd: projectPath2()
+  });
+  if (result.isErr()) {
+    log3.error("There was an error generating your library entry points", result.error);
+    process.exit();
+  }
+  log3.success("Library entry points generated successfully");
+}
+async function generateWebTypes2(options) {
+  const result = await runNpmScript(NpmScript.GenerateWebTypes, options);
+  if (result.isErr()) {
+    log3.error("There was an error generating the web-types.json file.", result.error);
+    process.exit();
+  }
+  log3.success("Successfully generated the web-types.json file");
+}
+async function generateVsCodeCustomData2(options) {
+  const result = await generateVsCodeCustomData();
+  if (result.isErr()) {
+    log3.error("There was an error generating the custom-elements.json file.", result.error);
+    process.exit();
+  }
+  await runAction(Action.LintFix, { verbose: true });
+  log3.success("Successfully generated the custom-elements.json file");
+}
+async function generateIdeHelpers(options) {
+  const result = await runNpmScript(NpmScript.GenerateIdeHelpers, options);
+  if (result.isErr()) {
+    log3.error("There was an error generating IDE helpers.", result.error);
+    process.exit();
+  }
+  await runAction(Action.LintFix, { verbose: true });
+  log3.success("Successfully generated IDE helpers");
+}
+async function generateComponentMeta(options) {
+  const result = await generateVsCodeCustomData();
+  if (result.isErr()) {
+    log3.error("There was an error generating your component meta information.", result.error);
+    process.exit();
+  }
+  await runAction(Action.LintFix, { verbose: true });
+  log3.success("Successfully generated component meta information");
+}
+async function generateTypes(options) {
+  const result = await runNpmScript(NpmScript.GenerateTypes, {
+    cwd: frameworkPath(),
+    ...options
+  });
+  if (result.isErr()) {
+    log3.error("There was an error generating your types.", result.error);
+    process.exit();
+  }
+  log3.success("Types were generated successfully");
+}
+function generatePkgxConfig() {
+  log3.success("Successfully generated `./pkgx.yaml` based on your config");
+}
+async function generateSeeder() {
+}
+async function generateCoreSymlink() {
+  await runCommand2(`ln -s ${frameworkPath()} ${projectPath2(".stacks")}`);
+}
+
+// src/build.ts
+import {NpmScript as NpmScript2} from "@stacksjs/enums";
+import {log as log4} from "@stacksjs/logging";
+import {hasComponents, hasFunctions} from "@stacksjs/storage";
+import {runNpmScript as runNpmScript2} from "@stacksjs/utils";
+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()) {
+    log4.info("Building your component library...");
+    await runNpmScript2(NpmScript2.BuildComponents, options);
+    log4.success("Your component library was built successfully");
+  } else {
+    log4.warn("No components found.");
+    log4.info("Before you can build components,");
+    log4.info("you need to have created some in the ./components folder.");
+  }
+}
+async function webComponentLibrary(options) {
+  log4.info("Building your component library for production use & npm/CDN distribution...");
+  if (hasComponents()) {
+    await runNpmScript2(NpmScript2.BuildWebComponents, options);
+    log4.success("Your Web Component library was built successfully");
+  } else {
+    log4.info("No components found.");
+  }
+}
+async function docs(options) {
+  log4.info("Building the documentation site...");
+  await runNpmScript2(NpmScript2.BuildDocs, options);
+  log4.success("Docs built successfully");
+}
+async function stacks(options) {
+  log4.info("Building the Stacks Framework...");
+  await runNpmScript2(NpmScript2.BuildStacks, options);
+  log4.success("Stacks built successfully");
+}
+async function functionsLibrary(options) {
+  if (hasFunctions()) {
+    log4.info("Building your functions library for production usages...");
+    log4.info("Production usages include: manual npm distribution and/or CDN distribution");
+    await runNpmScript2(NpmScript2.BuildFunctions, options);
+    log4.success("Functions library built successfully");
+  } else {
+    log4.info("No functions found");
+  }
+}
+export {
+  webComponentLibrary,
+  vueComponentLibrary,
+  stacks,
+  invoke2 as invoke,
+  functionsLibrary,
+  docs,
+  componentLibraries,
+  build
+};

package/dist/bump.js

@@ -0,0 +1,16 @@
+// @bun
+// src/bump.ts
+import {parseOptions, runCommand} from "@stacksjs/cli";
+import {path as p} from "@stacksjs/path";
+var options = parseOptions();
+var changelogCommand = options?.dryRun ? "buddy changelog --quiet --dry-run" : "buddy changelog --quiet";
+await runCommand(changelogCommand, {
+  cwd: p.projectPath()
+});
+var bumpCommand = options?.dryRun ? "bunx bumpp ./package.json ./**/package.json ../ide/vscode/package.json --no-push" : "bunx bumpp ./package.json ./**/package.json ../ide/vscode/package.json --all";
+console.log(`Running: ${bumpCommand}`);
+console.log(`In frameworkPath: ${p.frameworkPath()}`);
+await runCommand(bumpCommand, {
+  cwd: p.frameworkPath("core"),
+  stdin: "inherit"
+});

package/dist/changelog.js

@@ -0,0 +1,17 @@
+// @bun
+// src/changelog.ts
+import {execSync, log, parseOptions, runCommand} from "@stacksjs/cli";
+import {projectPath} from "@stacksjs/path";
+log.debug("Generating changelog");
+var fromRevision = await execSync("git describe --abbrev=0 --tags HEAD^");
+log.debug("FromRevision", fromRevision);
+var toRevision = await execSync("git describe");
+log.debug("ToRevision", toRevision);
+var options = parseOptions();
+log.debug("Changelog Options", options);
+var command = options?.dryRun ? `bunx changelogen --no-output --from ${fromRevision} --to ${toRevision}` : `bunx changelogen --output CHANGELOG.md --from ${fromRevision} --to ${toRevision}`;
+await runCommand(command, {
+  cwd: projectPath(),
+  quiet: options?.quiet,
+  verbose: options?.verbose
+});

package/dist/clean.js

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

package/dist/commit.js

@@ -0,0 +1,17 @@
+// @bun
+// src/commit.ts
+import {NpmScript} from "@stacksjs/enums";
+import {log} from "@stacksjs/logging";
+import {runNpmScript} from "@stacksjs/utils";
+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.js

@@ -0,0 +1,14 @@
+#!/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")]
+];
+destinations.forEach(([src, dest]) => {
+  copyFolder(src, dest);
+});

package/dist/database/seed.js

@@ -0,0 +1,8 @@
+// @bun
+// src/database/seed.ts
+import process from "process";
+import {log} from "@stacksjs/cli";
+import {seed} from "@stacksjs/database";
+log.info("Seeding database...");
+await seed();
+process.exit(0);

package/dist/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.corePath()
+});
+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 build.ts", {
+  cwd: p.frameworkPath("server")
+});
+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.frameworkCloudPath()
+});

package/dist/dev/components.js

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

package/dist/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/dev/index.js

@@ -0,0 +1,112 @@
+// @bun
+// src/helpers/utils.ts
+import {buddyOptions, runCommand, runCommands} from "@stacksjs/cli";
+import {err} from "@stacksjs/error-handling";
+import {log} from "@stacksjs/logging";
+import * as p from "@stacksjs/path";
+import {glob} from "@stacksjs/storage";
+var {Glob } = globalThis.Bun;
+async function runAction(action, options) {
+  const glob2 = new Glob("**/*.ts");
+  const scanOptions = { cwd: p.userActionsPath(), onlyFiles: true };
+  for await (const file of glob2.scan(scanOptions)) {
+    log.debug("file", file);
+    if (file === `${action}.ts` || file.endsWith(`${action}.ts`))
+      return (await import(p.userActionsPath(file))).default.handle();
+    const a = await import(p.userActionsPath(file));
+    if (a.name === action)
+      return await a.handle();
+  }
+  const opts = buddyOptions();
+  const path = p.relativeActionsPath(`src/${action}.ts`);
+  const cmd = `bun --bun ${path} ${opts}`.trimEnd();
+  const optionsWithCwd = {
+    cwd: options?.cwd || p.projectPath(),
+    ...options
+  };
+  log.debug("runAction:", cmd);
+  log.debug("action options:", optionsWithCwd);
+  return await runCommand(cmd, optionsWithCwd);
+}
+async function runActions(actions, options) {
+  log.debug("runActions:", actions, options);
+  if (!actions.length)
+    return err("No actions were specified");
+  for (const action of actions) {
+    log.debug(`running action "${action}"`);
+    if (!hasAction(action))
+      return err(`The specified action "${action}" does not exist`);
+  }
+  const opts = buddyOptions();
+  const o = {
+    cwd: options?.cwd || p.projectPath(),
+    ...options
+  };
+  const commands = actions.map((action) => `bun --bun ${p.relativeActionsPath(`src/${action}.ts`)} ${opts}`);
+  log.debug("commands:", commands);
+  return await runCommands(commands, o);
+}
+function hasAction(action) {
+  const userActionPatterns = [
+    `${action}.ts`,
+    `${action}`,
+    `Dashboard/${action}.ts`,
+    `Dashboard/${action}`,
+    `Buddy/${action}.ts`,
+    `Buddy/${action}`
+  ];
+  const actionPatterns = [`src/${action}.ts`, `src/${action}`, `${action}.ts`, `${action}`];
+  const userActionFiles = glob.sync(userActionPatterns.map((pattern) => p.userActionsPath(pattern)));
+  const actionFiles = glob.sync(actionPatterns.map((pattern) => p.actionsPath(pattern)));
+  return userActionFiles.length > 0 || actionFiles.length > 0;
+}
+
+// src/dev/index.ts
+import {Action} from "@stacksjs/enums";
+import {log as log2} from "@stacksjs/logging";
+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 runDashboardDevServer(options) {
+  log2.info("Starting your Dashboard...");
+  await runAction(Action.DevDashboard, options);
+}
+async function runSystemTrayDevServer(options) {
+  log2.info("Starting your System Tray...");
+  await runAction(Action.DevSystemTray, 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 {
+  runSystemTrayDevServer,
+  runFrontendDevServer,
+  runDocsDevServer,
+  runDevServer,
+  runDesktopDevServer,
+  runDashboardDevServer,
+  runComponentsDevServer,
+  runBackendDevServer,
+  runApiDevServer
+};

package/dist/examples.js

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