@stacksjs/actions 0.59.10 → 0.61.0

package/dist/fresh.js

@@ -0,0 +1,19 @@
+// @bun
+// src/fresh.ts
+import process from "process";
+import {runCommand} from "@stacksjs/cli";
+import {handleError} from "@stacksjs/error-handling";
+import {logger} from "@stacksjs/logging";
+import {projectPath} from "@stacksjs/path";
+import {ExitCode} from "@stacksjs/types";
+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/generate/component-meta.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/helpers/component-meta.ts
+import {path as path2, frameworkPath, join, 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", "components/*.vue", "components/**/*.vue"], {
+    cwd: projectPath(),
+    absolute: true
+  });
+  components.forEach((componentPath) => {
+    const componentExportName = path2.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";
+log.info("Generating component meta...");
+if (hasComponents())
+  generateComponentMeta();
+else
+  log.info("No components found. Skipping component meta generation.");
+log.success("Generated component meta.");

package/dist/generate/ide-helpers.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/helpers/vscode-custom-data.ts
+import {log} 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 {
+    log.info("Generating custom-elements.json...");
+    await writeTextFile({
+      path: customElementsDataPath(),
+      data: generateComponentInfoData()
+    });
+    log.success("Generated custom-elements.json for IDEs.");
+  } catch (err) {
+    log.error("There was an error generating the custom-elements.json file.", err);
+  }
+}
+async function generateWebTypes() {
+  log.info("Generating web-types.json...");
+  log.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/ide-helpers.ts
+import {log as log2} from "@stacksjs/logging";
+import {hasComponents} from "@stacksjs/storage";
+if (hasComponents()) {
+  await generateWebTypes();
+  await generateVsCodeCustomData();
+} else {
+  log2.info("No components found. Skipping IDE helper generation.");
+}

package/dist/generate/index.js

@@ -0,0 +1,251 @@
+// @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")}`);
+}
+export {
+  invoke,
+  generateWebTypes2 as generateWebTypes,
+  generateVsCodeCustomData2 as generateVsCodeCustomData,
+  generateTypes,
+  generateSeeder,
+  generatePkgxConfig,
+  generateLibEntries,
+  generateIdeHelpers,
+  generateCoreSymlink,
+  generateComponentMeta,
+  generate
+};

package/dist/generate/lib-entries.js

@@ -0,0 +1,175 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/helpers/lib-entries.ts
+import process from "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";
+
+// ../../../../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/lib-entries.ts
+async function generateLibEntry(type) {
+  await createLibraryEntryPoint(type);
+}
+async function createLibraryEntryPoint(type) {
+  if (type === "vue-components")
+    await createVueLibraryEntryPoint();
+  if (type === "web-components")
+    await createWebComponentLibraryEntryPoint();
+  if (type === "functions")
+    await createFunctionLibraryEntryPoint();
+}
+async function createVueLibraryEntryPoint(type = "vue-components") {
+  log.info("Ensuring Component Library Entry Point...");
+  await writeTextFile({
+    path: libraryEntryPath(type),
+    data: generateEntryPointData(type)
+  }).catch((err) => {
+    log.error("There was an error generating the Vue Component Library Entry Point.", err);
+    process.exit(ExitCode.FatalError);
+  });
+  log.success("Created Vue Component Library Entry Point");
+}
+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");
+}
+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");
+}
+function generateEntryPointData(type) {
+  let arr = [];
+  if (type === "functions") {
+    if (!library_default.functions?.files) {
+      log.error(new Error("There are no functions defined to be built. Please check your config/library.ts file for potential adjustments"));
+      process.exit();
+    }
+    for (const fx of library_default.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\n");
+  }
+  if (type === "vue-components") {
+    if (!library_default.vueComponents?.tags) {
+      log.error(new Error("There are no components defined to be built. Please check your config/library.ts file for potential adjustments"));
+      process.exit();
+    }
+    arr = determineResetPreset();
+    for (const component of library_default.vueComponents.tags.map((tag) => tag.name)) {
+      if (Array.isArray(component))
+        arr.push(`export { default as ${component[1]} } from '${componentsPath(component[0])}.stx'`);
+      else
+        arr.push(`export { default as ${component} } from '${componentsPath(component)}.stx'`);
+    }
+    return arr.join("\r\n");
+  }
+  arr = determineResetPreset();
+  const imports = [...arr, "import { defineCustomElement } from 'vue'"];
+  const declarations = [];
+  const definitions = [];
+  if (!library_default.webComponents?.tags) {
+    log.error(new Error("There are no components defined to be built. Please check your config/library.ts file for potential adjustments"));
+    process.exit();
+  }
+  for (const component of library_default.webComponents.tags.map((tag) => tag.name)) {
+    if (Array.isArray(component)) {
+      imports.push(`import ${component[1]} from '${componentsPath(component[0])}.stx'`);
+      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)}.stx'`);
+      declarations.push(`const ${component}CustomElement = defineCustomElement(${component})`);
+      definitions.push(`customElements.define('${kebabCase(component)}', ${component}CustomElement)`);
+    }
+  }
+  return [...imports, ...declarations, ...definitions].join("\r\n");
+}
+
+// src/generate/lib-entries.ts
+import {library as library2} from "@stacksjs/config";
+import {log as log2} from "@stacksjs/logging";
+import {hasComponents, hasFunctions} from "@stacksjs/storage";
+if (library2.releaseable && hasComponents()) {
+  await generateLibEntry("vue-components");
+  await generateLibEntry("web-components");
+} else {
+  log2.info("No components found. Skipping building component entry points.");
+}
+if (library2.releaseable && hasFunctions())
+  await generateLibEntry("functions");
+else
+  log2.info("No functions found. Skipping building function entry point.");

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

@@ -0,0 +1,96 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/helpers/vscode-custom-data.ts
+import {log} 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 {
+    log.info("Generating custom-elements.json...");
+    await writeTextFile({
+      path: customElementsDataPath(),
+      data: generateComponentInfoData()
+    });
+    log.success("Generated custom-elements.json for IDEs.");
+  } catch (err) {
+    log.error("There was an error generating the custom-elements.json file.", err);
+  }
+}
+async function generateWebTypes() {
+  log.info("Generating web-types.json...");
+  log.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/vscode-custom-data.ts
+import {log as log2} from "@stacksjs/logging";
+import {hasComponents} from "@stacksjs/storage";
+log2.info("Generating VS Code custom data...");
+if (hasComponents())
+  await generateVsCodeCustomData();
+else
+  log2.info("No components found. Skipping VS Code custom data generation.");
+log2.success("Generated VS Code custom data.");