@stacksjs/actions 0.43.1 → 0.44.8

package/README.md

@@ -13,15 +13,13 @@ This package contains the Stacks Actions.
 
 ## 🤖 Usage
 
-wip
-
 ```bash
 pnpm i -D @stacksjs/actions
 ```
 
 Now, you can use it in your project:
 
-```js
+```ts
 import actions from '@stacksjs/actions'
 
 // wip

package/dist/add.d.ts

@@ -0,0 +1,11 @@
+import type { AddOptions } from '@stacksjs/types';
+export declare function invoke(options: AddOptions): Promise<void>;
+/**
+ * An alias of the invoke method.
+ * @param options
+ * @returns
+ */
+export declare function add(options: AddOptions): Promise<void>;
+export declare function addTable(): Promise<void>;
+export declare function addCalendar(): Promise<void>;
+export declare function installPackages(names: string[]): Promise<void>;

package/dist/add.mjs

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

package/dist/build.d.ts

@@ -0,0 +1,14 @@
+import { type BuildOptions } from '@stacksjs/types';
+export declare function invoke(options: BuildOptions): Promise<void>;
+/**
+ * An alias of the invoke method.
+ * @param options
+ * @returns
+ */
+export declare function build(options: BuildOptions): Promise<void>;
+export declare function componentLibraries(options: BuildOptions): Promise<void>;
+export declare function vueComponentLibrary(options: BuildOptions): Promise<void>;
+export declare function webComponentLibrary(options: BuildOptions): Promise<void>;
+export declare function docs(options: BuildOptions): Promise<void>;
+export declare function stacks(options: BuildOptions): Promise<void>;
+export declare function functionsLibrary(options: BuildOptions): Promise<void>;

package/dist/build.mjs

@@ -0,0 +1,68 @@
+import { log } from "@stacksjs/logging";
+import { hasComponents, hasFunctions } from "@stacksjs/storage";
+import { runNpmScript } from "@stacksjs/utils";
+import { NpmScript } from "@stacksjs/types";
+import { types as generateTypes } from "./generate.mjs";
+export async function invoke(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();
+}
+export async function build(options) {
+  return invoke(options);
+}
+export async function componentLibraries(options) {
+  await runNpmScript(NpmScript.GenerateEntries, options);
+  await vueComponentLibrary(options);
+  await webComponentLibrary(options);
+}
+export async function vueComponentLibrary(options) {
+  if (hasComponents()) {
+    log.info("Building your component library...");
+    await runNpmScript(NpmScript.BuildComponents, options);
+    log.success("Your component library was built successfully");
+  } else {
+    log.warn("No components found.");
+    log.info("Before you can build components,");
+    log.info("you need to have created some in the ./components folder.");
+  }
+}
+export async function webComponentLibrary(options) {
+  log.info("Building your component library for production use & npm/CDN distribution...");
+  if (hasComponents()) {
+    await runNpmScript(NpmScript.BuildWebComponents, options);
+    log.success("Your Web Component library was built successfully");
+  } else {
+    log.info("No components found.");
+  }
+}
+export async function docs(options) {
+  log.info("Building the documentation site...");
+  await runNpmScript(NpmScript.BuildDocs, options);
+  log.success("Docs built successfully");
+}
+export async function stacks(options) {
+  log.info("Building the Stacks Framework...");
+  await runNpmScript(NpmScript.BuildStacks, options);
+  log.success("Stacks built successfully");
+}
+export async function functionsLibrary(options) {
+  if (hasFunctions()) {
+    log.info("Building your functions library for production usages...");
+    log.info("Production usages include: manual npm distribution and/or CDN distribution");
+    await runNpmScript(NpmScript.BuildFunctions, options);
+    log.success("Functions library built successfully");
+  } else {
+    log.info("No functions found");
+  }
+}

package/dist/clean.d.ts

@@ -0,0 +1,8 @@
+import { type CleanOptions } from '@stacksjs/types';
+export declare function invoke(options?: CleanOptions): Promise<void>;
+/**
+ * An alias of the invoke method.
+ * @param options
+ * @returns
+ */
+export declare function clean(options: CleanOptions): Promise<void>;

package/dist/clean.mjs

@@ -0,0 +1,15 @@
+import { log, runCommand } from "@stacksjs/cli";
+import { ExitCode, NpmScript } from "@stacksjs/types";
+export async function invoke(options) {
+  log.info("Running clean command...");
+  const result = await runCommand(NpmScript.Clean, options);
+  if (result.isOk()) {
+    log.success("Cleaned up");
+    process.exit(ExitCode.Success);
+  }
+  log.error(result.error);
+  process.exit(ExitCode.FatalError);
+}
+export async function clean(options) {
+  return invoke(options);
+}

package/dist/commit.d.ts

@@ -0,0 +1,8 @@
+import type { CleanOptions } from '@stacksjs/types';
+export declare function invoke(options: CleanOptions): Promise<void>;
+/**
+ * An alias of the invoke method.
+ * @param options
+ * @returns
+ */
+export declare function commit(options: CleanOptions): Promise<void>;

package/dist/commit.mjs

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

package/dist/dev.d.ts

@@ -0,0 +1,13 @@
+import type { DevOptions } from '@stacksjs/types';
+export declare function invoke(options: DevOptions): Promise<void>;
+/**
+ * An alias of the invoke method.
+ * @param options
+ * @returns
+ */
+export declare function dev(options: DevOptions): Promise<void>;
+export declare function components(options: DevOptions): Promise<void>;
+export declare function docs(options: DevOptions): Promise<void>;
+export declare function desktop(options: DevOptions): Promise<void>;
+export declare function pages(options: DevOptions): Promise<void>;
+export declare function functions(options: DevOptions): Promise<void>;

package/dist/dev.mjs

@@ -0,0 +1,38 @@
+import { log } from "@stacksjs/logging";
+import { runNpmScript } from "@stacksjs/utils";
+import { NpmScript } from "@stacksjs/types";
+export async function invoke(options) {
+  if (options.components || options.all)
+    await components(options);
+  else if (options.docs || options.all)
+    await docs(options);
+  else if (options.pages || options.all)
+    await pages(options);
+  else if (options.functions || options.all)
+    await functions(options);
+  else if (options.desktop || options.all)
+    await desktop(options);
+}
+export async function dev(options) {
+  return invoke(options);
+}
+export async function components(options) {
+  log.info("Starting your components dev server...");
+  await runNpmScript(NpmScript.DevComponents, options);
+}
+export async function docs(options) {
+  log.info("Starting your docs dev server...");
+  await runNpmScript(NpmScript.DevDocs, options);
+}
+export async function desktop(options) {
+  log.info("Starting your Desktop engine...");
+  await runNpmScript(NpmScript.DevDesktop, options);
+}
+export async function pages(options) {
+  log.info("Starting your page engine...");
+  await runNpmScript(NpmScript.DevPages, options);
+}
+export async function functions(options) {
+  log.info("Starting your function's dev server...");
+  await runNpmScript(NpmScript.DevFunctions, options);
+}

package/dist/examples.d.ts

@@ -0,0 +1,10 @@
+import { type ExamplesOptions } from '@stacksjs/types';
+export declare function invoke(options: ExamplesOptions): Promise<void>;
+/**
+ * An alias of the invoke method.
+ * @param options
+ * @returns
+ */
+export declare function examples(options: ExamplesOptions): Promise<void>;
+export declare function componentExample(options: ExamplesOptions): Promise<void>;
+export declare function webComponentExample(options: ExamplesOptions): Promise<void>;

package/dist/examples.mjs

@@ -0,0 +1,33 @@
+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) {
+  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.");
+}
+export async function examples(options) {
+  return invoke(options);
+}
+export 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.");
+  }
+}
+export 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);
+  }
+}

package/dist/fresh.d.ts

@@ -0,0 +1,8 @@
+import type { CliOptions as FreshOptions } from '@stacksjs/types';
+export declare function invoke(options?: FreshOptions): Promise<void>;
+/**
+ * An alias of the invoke method.
+ * @param options
+ * @returns
+ */
+export declare function fresh(options: FreshOptions): Promise<void>;

package/dist/fresh.mjs

@@ -0,0 +1,17 @@
+import { intro, outro, runCommands } from "@stacksjs/cli";
+import { ExitCode } from "@stacksjs/types";
+export async function invoke(options) {
+  const perf = intro("buddy fresh");
+  const results = await runCommands(["pnpm run clean", "pnpm install"], options);
+  for (const result of results) {
+    if (result.isErr()) {
+      outro("While running the fresh command, there was an issue", { startTime: perf, useSeconds: true, isError: true }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+  }
+  outro("Freshly reinstalled your dependencies.", { startTime: perf, useSeconds: true });
+  process.exit(ExitCode.Success);
+}
+export async function fresh(options) {
+  return invoke(options);
+}

package/dist/generate-component-meta.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { log } from "@stacksjs/x-ray";
+import { log } from "@stacksjs/logging";
 import { hasComponents } from "@stacksjs/storage";
 import { generateComponentMeta } from "./helpers/component-meta.mjs";
 if (hasComponents())

package/dist/generate-ide-helpers.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { log } from "@stacksjs/x-ray";
+import { log } from "@stacksjs/logging";
 import { hasComponents } from "@stacksjs/storage";
 import { generateVsCodeCustomData } from "./helpers/vscode-custom-data.mjs";
 if (hasComponents()) {

package/dist/generate-lib-entries.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { log } from "@stacksjs/x-ray";
+import { log } from "@stacksjs/logging";
 import { hasComponents, hasFunctions } from "@stacksjs/storage";
 import { generateLibEntry } from "./helpers/lib-entries.mjs";
 if (hasComponents()) {

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

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { log } from "@stacksjs/x-ray";
+import { log } from "@stacksjs/logging";
 import { hasComponents } from "@stacksjs/storage";
 import { generateVsCodeCustomData } from "./helpers/vscode-custom-data.mjs";
 if (hasComponents())

package/dist/generate.d.ts

@@ -0,0 +1,15 @@
+import type { GeneratorOptions } from '@stacksjs/types';
+export declare function invoke(options?: GeneratorOptions): Promise<void>;
+/**
+ * An alias of the invoke method.
+ * @param options
+ * @returns
+ */
+export declare function generate(options: GeneratorOptions): Promise<void>;
+export declare function libEntries(options: GeneratorOptions): Promise<void>;
+export declare function vueCompat(options?: GeneratorOptions): Promise<void>;
+export declare function webTypes(options?: GeneratorOptions): Promise<void>;
+export declare function vsCodeCustomData(options?: GeneratorOptions): Promise<void>;
+export declare function ideHelpers(options?: GeneratorOptions): Promise<void>;
+export declare function componentMeta(options?: GeneratorOptions): Promise<void>;
+export declare function types(options?: GeneratorOptions): Promise<void>;

package/dist/generate.mjs

@@ -0,0 +1,84 @@
+import { log } from "@stacksjs/logging";
+import { NpmScript } from "@stacksjs/types";
+import { runNpmScript } from "@stacksjs/utils";
+import { projectPath } from "@stacksjs/path";
+import { runCommand } from "@stacksjs/cli";
+import { lintFix } from "./lint.mjs";
+export async function invoke(options) {
+  if (options?.types)
+    await types(options);
+  else if (options?.entries)
+    await libEntries(options);
+  else if (options?.webTypes)
+    await webTypes(options);
+  else if (options?.customData)
+    await vsCodeCustomData(options);
+  else if (options?.ideHelpers)
+    await ideHelpers(options);
+  else if (options?.vueCompatibility)
+    await vueCompat(options);
+  else if (options?.componentMeta)
+    await componentMeta(options);
+}
+export async function generate(options) {
+  return invoke(options);
+}
+export async function libEntries(options) {
+  const result = await runCommand("esno .stacks/core/actions/src/generate-package-json.ts", { ...options, debug: true, cwd: projectPath() });
+  if (result.isErr()) {
+    log.error("There was an error generating your library entry points.", result.error);
+    process.exit();
+  }
+  log.success("Library entry points were generated successfully");
+}
+export async function vueCompat(options) {
+  const result = await runNpmScript(NpmScript.GenerateVueCompat, options);
+  if (result.isErr()) {
+    log.error("There was an error generating Vue 2 compatibility.", result.error);
+    process.exit();
+  }
+  log.success("Libraries are now Vue 2 & 3 compatible");
+}
+export async function webTypes(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();
+  }
+  log.success("Successfully generated the web-types.json file");
+}
+export async function vsCodeCustomData(options) {
+  const result = await runNpmScript(NpmScript.GenerateVsCodeCustomData, options);
+  if (result.isErr()) {
+    log.error("There was an error generating the custom-elements.json file.", result.error);
+    process.exit();
+  }
+  await lintFix({ fix: true });
+  log.success("Successfully generated the custom-elements.json file");
+}
+export async function ideHelpers(options) {
+  const result = await runNpmScript(NpmScript.GenerateIdeHelpers, options);
+  if (result.isErr()) {
+    log.error("There was an error generating IDE helpers.", result.error);
+    process.exit();
+  }
+  await lintFix({ fix: true });
+  log.success("Successfully generated IDE helpers");
+}
+export async function componentMeta(options) {
+  const result = await runNpmScript(NpmScript.GenerateComponentMeta, options);
+  if (result.isErr()) {
+    log.error("There was an error generating your component meta information.", result.error);
+    process.exit();
+  }
+  await lintFix({ fix: true });
+  log.success("Successfully generated component meta information");
+}
+export async function types(options) {
+  const result = await runNpmScript(NpmScript.GenerateTypes, options);
+  if (result.isErr()) {
+    log.error("There was an error generating your types.", result.error);
+    process.exit();
+  }
+  log.success("Types were generated successfully");
+}

package/dist/helpers/index.d.ts

@@ -0,0 +1,6 @@
+export * from './component-meta';
+export * from './lib-entries';
+export * from './package-json';
+export * from './utils';
+export * from './vscode-custom-data';
+export * from './vue-compat';

package/dist/helpers/index.mjs

@@ -0,0 +1,6 @@
+export * from "./component-meta.mjs";
+export * from "./lib-entries.mjs";
+export * from "./package-json.mjs";
+export * from "./utils.mjs";
+export * from "./vscode-custom-data.mjs";
+export * from "./vue-compat.mjs";

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

@@ -1,4 +1,4 @@
-import { type LibEntryType } from '@stacksjs/types';
+import type { LibEntryType } from '@stacksjs/types';
 /**
  * Based on the config values, this method
  * will generate the library entry points.

package/dist/helpers/lib-entries.mjs

@@ -1,9 +1,7 @@
-import { log } from "@stacksjs/x-ray";
-import { kebabCase } from "@stacksjs/strings";
+import { log } from "@stacksjs/logging";
 import { libraryEntryPath } from "@stacksjs/path";
 import { writeTextFile } from "@stacksjs/storage";
 import { determineResetPreset } from "@stacksjs/utils";
-import { ExitCode } from "@stacksjs/types";
 import { library } from "@stacksjs/config";
 export async function generateLibEntry(type) {
   try {
@@ -14,8 +12,8 @@ export async function generateLibEntry(type) {
     if (type === "functions")
       await createFunctionLibraryEntryPoint();
   } catch (err) {
-    log.error(err);
-    process.exit(ExitCode.FatalError);
+    log.error("There was an error generating the library entry point.", err);
+    process.exit();
   }
 }
 export async function createVueLibraryEntryPoint() {
@@ -24,7 +22,7 @@ export async function createVueLibraryEntryPoint() {
     path: libraryEntryPath("vue-components"),
     data: generateEntryPointData("vue-components")
   });
-  log.success("Created the Vue component library entry point.");
+  log.success("Created Vue component library entry point.");
 }
 export async function createWebComponentLibraryEntryPoint() {
   log.info("Creating the Web Component library entry point...");
@@ -32,7 +30,7 @@ export async function createWebComponentLibraryEntryPoint() {
     path: libraryEntryPath("web-components"),
     data: generateEntryPointData("web-components")
   });
-  log.success("Created the Web Component library entry point.");
+  log.success("Created Web Component library entry point.");
 }
 export async function createFunctionLibraryEntryPoint() {
   log.info("Creating the Function library entry point...");
@@ -40,14 +38,14 @@ export async function createFunctionLibraryEntryPoint() {
     path: libraryEntryPath("functions"),
     data: generateEntryPointData("functions")
   });
-  log.success("Created the Functions library entry point.");
+  log.success("Created Functions library entry point.");
 }
 export function generateEntryPointData(type) {
   let arr = [];
   if (type === "functions") {
     if (!library.functions.functions) {
       log.error("There are no functions defined to be built. Please check your config/library.ts file for potential adjustments.");
-      process.exit(ExitCode.FatalError);
+      process.exit();
     }
     for (const fx of library.functions.functions) {
       if (Array.isArray(fx))
@@ -60,7 +58,7 @@ export function generateEntryPointData(type) {
   if (type === "vue-components") {
     if (!library.vueComponents.tags) {
       log.error("There are no components defined to be built. Please check your config/library.ts file for potential adjustments.");
-      process.exit(ExitCode.FatalError);
+      process.exit();
     }
     arr = determineResetPreset();
     for (const component of library.vueComponents.tags.map((tag) => tag.name)) {
@@ -77,7 +75,7 @@ export function generateEntryPointData(type) {
   const definitions = [];
   if (!library.webComponents.tags) {
     log.error("There are no components defined to be built. Please check your config/library.ts file for potential adjustments.");
-    process.exit(ExitCode.FatalError);
+    process.exit();
   }
   for (const component of library.webComponents.tags.map((tag) => tag.name)) {
     if (Array.isArray(component)) {

package/dist/helpers/package-json.mjs

@@ -1,10 +1,10 @@
-import { log } from "@stacksjs/x-ray";
+import { log } from "@stacksjs/logging";
 import { writeTextFile } from "@stacksjs/storage";
 import { packageJsonPath } from "@stacksjs/path";
 import { library } from "@stacksjs/config";
-import { packageManager } from "../../package.json";
+import { packageManager } from "../../package.json" assert { type: "json" };
 export async function generatePackageJson(type) {
-  let name, description, directory, keywords, config;
+  let name, description, directory, keywords, config, prettyName;
   if (type === "vue-components") {
     name = library.vueComponents.name;
     description = library.vueComponents.description;
@@ -70,15 +70,14 @@ export async function generatePackageJson(type) {
 }
 `
     });
-    let prettyName;
     if (type === "vue-components")
       prettyName = "Vue Component library";
     else if (type === "web-components")
       prettyName = "Web Component library";
     else if (type === "functions")
       prettyName = "Function Library";
-    log.success(`Created the ${prettyName} package.json`);
+    log.success(`Created ${prettyName} package.json`);
   } catch (err) {
-    log.error(err);
+    log.error(`There was an error creating the ${prettyName} package.json.`, err);
   }
 }

package/dist/helpers/utils.d.ts

@@ -0,0 +1,10 @@
+import type { CliOptions } from '@stacksjs/types';
+/**
+ * Run a command the Stacks way.
+ *
+ * @param command The action to invoke.
+ * @param options The options to pass to the command.
+ * @returns The result of the command.
+ */
+export declare function runAction(action: string, options?: CliOptions): Promise<any>;
+export declare function hasAction(action: string): boolean;

package/dist/helpers/utils.mjs

@@ -0,0 +1,17 @@
+import storage from "@stacksjs/storage";
+import { runCommand } from "@stacksjs/cli";
+import { actionsPath, functionsPath } from "@stacksjs/path";
+import { err } from "@stacksjs/error-handling";
+export async function runAction(action, options) {
+  if (!hasAction(action))
+    return err(`The specified action "${action}" does not exist`);
+  const cmd = `esno ${actionsPath(`${action}.ts`)}`;
+  return await runCommand(cmd, options);
+}
+export function hasAction(action) {
+  if (storage.isFile(functionsPath(`actions/${action}.ts`)))
+    return true;
+  if (storage.isFile(actionsPath(`${action}.ts`)))
+    return true;
+  return false;
+}

package/dist/helpers/vscode-custom-data.mjs

@@ -1,4 +1,4 @@
-import { log } from "@stacksjs/x-ray";
+import { log } from "@stacksjs/logging";
 import { customElementsDataPath } from "@stacksjs/path";
 import { writeTextFile } from "@stacksjs/storage";
 import { library } from "@stacksjs/config";
@@ -9,7 +9,7 @@ export async function generateVsCodeCustomData() {
       data: generateComponentInfoData()
     });
   } catch (err) {
-    log.error(err);
+    log.error("There was an error generating the VS Code custom data file.", err);
   }
 }
 function generateComponentInfoData() {

package/dist/index.d.ts

@@ -1,5 +1 @@
-export * from './helpers/component-meta';
-export * from './helpers/lib-entries';
-export * from './helpers/package-json';
-export * from './helpers/vscode-custom-data';
-export * from './helpers/vue-compat';
+export * from './helpers';

package/dist/index.mjs

@@ -1,5 +1 @@
-export * from "./helpers/component-meta.mjs";
-export * from "./helpers/lib-entries.mjs";
-export * from "./helpers/package-json.mjs";
-export * from "./helpers/vscode-custom-data.mjs";
-export * from "./helpers/vue-compat.mjs";
+export * from "./helpers/index.mjs";

package/dist/key.d.ts

@@ -0,0 +1,10 @@
+import type { CliOptions as KeyOptions } from '@stacksjs/types';
+export declare function invoke(options: KeyOptions): Promise<void>;
+/**
+ * An alias of the invoke method.
+ * @param options
+ * @returns
+ */
+export declare function key(options: KeyOptions): Promise<void>;
+export declare function generate(options: KeyOptions): Promise<boolean>;
+export declare function generateAppKey(): Promise<string>;