@stacksjs/actions 0.59.11 → 0.61.0

package/dist/helpers/component-meta.js

@@ -0,0 +1,50 @@
+// @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));
+  });
+}
+export {
+  generateComponentMeta
+};

package/dist/helpers/lib-entries.js

@@ -0,0 +1,166 @@
+// @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");
+}
+export {
+  generateLibEntry,
+  generateEntryPointData,
+  createWebComponentLibraryEntryPoint,
+  createVueLibraryEntryPoint,
+  createLibraryEntryPoint,
+  createFunctionLibraryEntryPoint
+};

package/dist/helpers/package-json.js

@@ -0,0 +1,146 @@
+// @bun
+// src/helpers/package-json.ts
+import {log} from "@stacksjs/logging";
+import {packageJsonPath} 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/package-json.ts
+async function generatePackageJson(type) {
+  let name;
+  let description;
+  let directory;
+  let keywords;
+  let config;
+  let prettyName;
+  if (type === "vue-components") {
+    name = library_default.vueComponents?.name;
+    description = library_default.vueComponents?.description;
+    directory = "components";
+    keywords = library_default.vueComponents?.keywords;
+    config = "vue-components";
+  } else if (type === "web-components") {
+    name = library_default.webComponents?.name;
+    description = library_default.webComponents?.description;
+    directory = "components";
+    keywords = library_default.webComponents?.keywords;
+    config = "web-components";
+  } else if (type === "functions") {
+    name = library_default.functions?.name;
+    description = library_default.functions?.description;
+    directory = "functions";
+    keywords = library_default.functions?.keywords;
+    config = "functions";
+  }
+  try {
+    await writeTextFile({
+      path: packageJsonPath(type),
+      data: `{
+  "name": "${name}",
+  "type": "module",
+  "version": "",
+  "packageManager": "bun",
+  "description": "${description}",
+  "author": "${library_default.author}",
+  "license": "MIT",
+  "homepage": "https://github.com/${library_default.repository}/tree/main/${directory}#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/${library_default.repository}.git",
+    "directory": "${directory}"
+  },
+  "bugs": {
+    "url": "https://github.com/${library_default.repository}/issues"
+  },
+  "keywords": ${JSON.stringify(keywords)},
+  "contributors": ${JSON.stringify(library_default.contributors)},
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.js"
+    }
+  },
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "vite build -c ../build/${config}.ts",
+    "prepublishOnly": "bun run build"
+  },
+  "devDependencies": {
+    "stacks": "workspace:*"
+  }
+}
+`
+    });
+    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 ${prettyName} package.json file`);
+  } catch (err) {
+    log.error(`There was an error creating the ${prettyName} package.json`, err);
+  }
+}
+export {
+  generatePackageJson
+};

package/dist/helpers/utils.js

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

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

@@ -0,0 +1,88 @@
+// @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}
+}
+`;
+};
+export {
+  generateWebTypes,
+  generateVsCodeCustomData
+};