@stacksjs/actions 0.57.3 → 0.58.19

package/dist/src/generate/ide-helpers.js

@@ -0,0 +1,83 @@
+#!/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";
+
+// /Users/chrisbreuer/Code/stacks/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",
+  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,
+    functions: [
+      "counter",
+      "dark"
+    ]
+  }
+};
+
+// src/helpers/vscode-custom-data.ts
+async function generateVsCodeCustomData() {
+  try {
+    await writeTextFile({
+      path: customElementsDataPath(),
+      data: generateComponentInfoData()
+    });
+  } catch (err) {
+    log.error("There was an error generating the VS Code custom data file.", err);
+  }
+}
+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 generateVsCodeCustomData();
+} else {
+  log2.info("No components found. Skipping IDE helper generation.");
+}

package/dist/src/generate/index.js

@@ -0,0 +1,161 @@
+// @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() {
+}
+export {
+  invoke,
+  generateWebTypes,
+  generateVueCompat,
+  generateVsCodeCustomData,
+  generateTypes,
+  generateSeeder,
+  generatePkgxConfig,
+  generateMigrations,
+  generateLibEntries,
+  generateIdeHelpers,
+  generateComponentMeta,
+  generate
+};

package/dist/src/generate/lib-entries.js

@@ -0,0 +1,168 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/helpers/lib-entries.ts
+import process from "process";
+import {log} from "@stacksjs/logging";
+import {kebabCase} from "@stacksjs/strings";
+import {componentsPath, functionsPath, libraryEntryPath} from "@stacksjs/path";
+import {writeTextFile} from "@stacksjs/storage";
+import {determineResetPreset} from "@stacksjs/utils";
+import {ExitCode} from "@stacksjs/types";
+
+// /Users/chrisbreuer/Code/stacks/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",
+  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,
+    functions: [
+      "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("Creating the Vue 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 the Vue component library entry point");
+}
+async function createWebComponentLibraryEntryPoint(type = "web-components") {
+  log.info("Creating the 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("Creating the 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?.functions) {
+      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?.functions) {
+      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 {log as log2} from "@stacksjs/logging";
+import {hasComponents, hasFunctions} from "@stacksjs/storage";
+if (hasComponents()) {
+  await generateLibEntry("vue-components");
+  await generateLibEntry("web-components");
+} else {
+  log2.info("No components found. Skipping building component entry points.");
+}
+if (hasFunctions())
+  await generateLibEntry("functions");
+else
+  log2.info("No functions found. Skipping building function entry point.");

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

@@ -0,0 +1,82 @@
+#!/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";
+
+// /Users/chrisbreuer/Code/stacks/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",
+  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,
+    functions: [
+      "counter",
+      "dark"
+    ]
+  }
+};
+
+// src/helpers/vscode-custom-data.ts
+async function generateVsCodeCustomData() {
+  try {
+    await writeTextFile({
+      path: customElementsDataPath(),
+      data: generateComponentInfoData()
+    });
+  } catch (err) {
+    log.error("There was an error generating the VS Code custom data file.", err);
+  }
+}
+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";
+if (hasComponents())
+  await generateVsCodeCustomData();
+else
+  log2.info("No components found. Skipping VS Code custom data generation.");

package/dist/src/generate/vue-compat.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/helpers/vue-compat.ts
+import {fs, glob} from "@stacksjs/storage";
+async function generateVueCompat(paths) {
+  const files = await glob(paths, {
+    onlyFiles: true
+  });
+  for (const f of files) {
+    const raw = await fs.readFile(f, "utf-8");
+    const changed = raw.replace(/"@vue\/composition-api"/g, "\'vue-demi\'").replace(/"vue"/g, "\'vue-demi\'").replace(/'vue'/g, "\'vue-demi\'");
+    await fs.writeFile(f, changed, "utf-8");
+  }
+}
+
+// src/generate/vue-compat.ts
+await generateVueCompat(["wip"]);

package/dist/{helpers/component-meta.mjs → src/helpers/component-meta.js}

@@ -1,29 +1,26 @@
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import fg from "fast-glob";
+// @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";
-import { frameworkPath, join, parse, projectPath } from "@stacksjs/path";
-export async function generateComponentMeta() {
-  const md = new MarkdownIt();
+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 tsconfigChecker = createComponentMetaChecker(projectPath("tsconfig.json"), checkerOptions);
   const filterMeta = (meta) => {
     const props = [];
     meta.props.forEach((prop) => {
-      if (prop.global)
+      if (prop?.global)
         return;
       const { name, description, required, type, default: defaultValue } = prop;
       props.push({
         name: `${name}${required ? "" : "?"}`,
         description: md.render(description),
-        // required,
         type,
         default: defaultValue || "unknown"
       });
@@ -34,7 +31,7 @@ export async function generateComponentMeta() {
       slots: meta.slots
     };
   };
-  const components = fg.sync(["components/*.vue", "components/**/*.vue"], {
+  const components = glob.sync(["components/*.stx", "components/**/*.stx"], {
     cwd: projectPath(),
     absolute: true
   });
@@ -48,3 +45,6 @@ export async function generateComponentMeta() {
     writeFileSync(metaJsonFilePath, JSON.stringify(meta, null, 4));
   });
 }
+export {
+  generateComponentMeta
+};

package/dist/src/helpers/index.js

@@ -0,0 +1,56 @@
+// @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`));
+}
+export {
+  runActions,
+  runAction,
+  hasAction
+};