@storm-software/workspace-tools 1.269.0 → 1.270.0

package/src/executors/npm-publish/untyped.ts

@@ -0,0 +1,56 @@
+import { defineUntypedSchema } from "untyped";
+
+export default defineUntypedSchema({
+  $schema: {
+    id: "NpmPublishExecutorSchema",
+    title: "Npm Publish Executor",
+    description: "A type definition for a Npm Publish executor schema"
+  },
+  packageRoot: {
+    $schema: {
+      title: "Package Root",
+      type: "string",
+      format: "path",
+      description: "The path to the package root"
+    }
+  },
+  registry: {
+    $schema: {
+      title: "Registry",
+      type: "string",
+      description: "The registry to publish to"
+    },
+    $default: "https://registry.npmjs.org/"
+  },
+  tag: {
+    $schema: {
+      title: "Tag",
+      type: "string",
+      description: "The tag to publish with"
+    },
+    $default: "latest"
+  },
+  otp: {
+    $schema: {
+      title: "One Time Password",
+      type: "number",
+      description: "The one time password"
+    }
+  },
+  dryRun: {
+    $schema: {
+      title: "Dry Run",
+      type: "boolean",
+      description: "Perform a dry run"
+    },
+    $default: false
+  },
+  firstRelease: {
+    $schema: {
+      title: "First Release",
+      type: "boolean",
+      description: "Publish the first release"
+    },
+    $default: false
+  }
+});

package/src/executors/size-limit/executor.spec.ts

@@ -0,0 +1,18 @@
+import { ExecutorContext } from "@nx/devkit";
+
+import executor from "./executor";
+import { SizeLimitExecutorSchema } from "./schema.d";
+
+const options: SizeLimitExecutorSchema = {};
+const context: ExecutorContext = {
+  root: "",
+  cwd: process.cwd(),
+  isVerbose: false,
+};
+
+describe("SizeLimit Executor", () => {
+  it("can run", async () => {
+    const output = await executor(options, context);
+    expect(output.success).toBe(true);
+  });
+});

package/src/executors/size-limit/executor.ts

@@ -0,0 +1,88 @@
+import type { ExecutorContext } from "@nx/devkit";
+import { joinPathFragments } from "@nx/devkit";
+import esBuildPlugin from "@size-limit/esbuild";
+import esBuildWhyPlugin from "@size-limit/esbuild-why";
+import filePlugin from "@size-limit/file";
+import type { StormWorkspaceConfig } from "@storm-software/config";
+import { writeInfo } from "@storm-software/config-tools";
+import sizeLimit from "size-limit";
+import { withRunExecutor } from "../../base/base-executor";
+import type { SizeLimitExecutorSchema } from "./schema.d";
+
+// export default [
+//   {
+//     async finally(config, check) {
+//       let { esbuildVisualizerFile } = check;
+
+//       if (esbuildVisualizerFile) {
+//         await open(esbuildVisualizerFile);
+//       }
+//     },
+
+//     name: "@size-limit/esbuild-why",
+//     async step81(config, check) {
+//       if (config.why && check.esbuildMetafile) {
+//         let result = await visualizer(check.esbuildMetafile);
+//         let file = join(config.saveBundle ?? "", getReportName(config, check));
+//         check.esbuildVisualizerFile = file;
+//         writeFileSync(file, result);
+//       }
+//     }
+//   }
+// ];
+
+export async function sizeLimitExecutorFn(
+  options: SizeLimitExecutorSchema,
+  context: ExecutorContext,
+  config?: StormWorkspaceConfig
+) {
+  if (
+    !context?.projectName ||
+    !context.projectsConfigurations?.projects ||
+    !context.projectsConfigurations.projects[context.projectName]
+  ) {
+    throw new Error(
+      "The Size-Limit process failed because the context is not valid. Please run this command from a workspace."
+    );
+  }
+
+  writeInfo(`📏 Running Size-Limit on ${context.projectName}`, config);
+
+  sizeLimit([filePlugin, esBuildPlugin, esBuildWhyPlugin], {
+    checks:
+      options.entry ??
+      context.projectsConfigurations.projects[context.projectName]
+        ?.sourceRoot ??
+      joinPathFragments(
+        context.projectsConfigurations.projects[context.projectName]?.root ??
+          "./",
+        "src"
+      )
+  }).then(result => {
+    writeInfo(
+      `📏 ${context.projectName} Size-Limit result: ${JSON.stringify(result)}`,
+      config
+    );
+  });
+
+  return {
+    success: true
+  };
+}
+
+export default withRunExecutor<SizeLimitExecutorSchema>(
+  "Size-Limit Performance Test Executor",
+  sizeLimitExecutorFn,
+  {
+    skipReadingConfig: false,
+    hooks: {
+      applyDefaultOptions: (
+        options: SizeLimitExecutorSchema
+      ): SizeLimitExecutorSchema => {
+        // options.entry ??= "{sourceRoot}/index.ts";
+
+        return options;
+      }
+    }
+  }
+);

package/src/executors/size-limit/untyped.ts

@@ -0,0 +1,22 @@
+import { defineUntypedSchema } from "untyped";
+import baseExecutorSchema from "../../base/base-executor.untyped";
+
+export default defineUntypedSchema({
+  ...baseExecutorSchema,
+  $schema: {
+    id: "SizeLimitExecutorSchema",
+    title: "Size Limit Executor",
+    description: "A type definition for a Size Limit executor schema",
+  },
+  entry: {
+    $schema: {
+      title: "Entry",
+      type: "array",
+      description: "The path to the entry file",
+      items: {
+        type: "string",
+        format: "path",
+      },
+    },
+  },
+});

package/src/executors/typia/executor.ts

@@ -0,0 +1,54 @@
+import type { ExecutorContext } from "@nx/devkit";
+import type { StormWorkspaceConfig } from "@storm-software/config";
+import { writeInfo } from "@storm-software/config-tools/logger/console";
+import { removeSync } from "fs-extra";
+import { TypiaProgrammer } from "typia/lib/programmers/TypiaProgrammer.js";
+import { withRunExecutor } from "../../base/base-executor";
+import type { TypiaExecutorSchema } from "./schema.d";
+
+export async function typiaExecutorFn(
+  options: TypiaExecutorSchema,
+  _: ExecutorContext,
+  config: StormWorkspaceConfig
+) {
+  if (options.clean !== false) {
+    writeInfo(`🧹 Cleaning output path: ${options.outputPath}`, config);
+    removeSync(options.outputPath);
+  }
+
+  await Promise.all(
+    options.entry!.map(entry => {
+      writeInfo(`🚀 Running Typia on entry: ${entry}`, config);
+
+      return TypiaProgrammer.build({
+        input: entry,
+        output: options.outputPath!,
+        project: options.tsconfig!
+      });
+    })
+  );
+
+  return {
+    success: true
+  };
+}
+
+export default withRunExecutor<TypiaExecutorSchema>(
+  "Typia runtime validation generator",
+  typiaExecutorFn,
+  {
+    skipReadingConfig: false,
+    hooks: {
+      applyDefaultOptions: (
+        options: TypiaExecutorSchema
+      ): TypiaExecutorSchema => {
+        options.entry ??= ["{sourceRoot}/index.ts"];
+        options.outputPath ??= "{sourceRoot}/__generated__/typia";
+        options.tsconfig ??= "{projectRoot}/tsconfig.json";
+        options.clean ??= true;
+
+        return options;
+      }
+    }
+  }
+);

package/src/executors/typia/untyped.ts

@@ -0,0 +1,48 @@
+import { defineUntypedSchema } from "untyped";
+import baseExecutorSchema from "../../base/base-executor.untyped";
+
+export default defineUntypedSchema({
+  ...baseExecutorSchema,
+  $schema: {
+    id: "TypiaExecutorSchema",
+    title: "Typia Executor",
+    description: "A type definition for a Typia executor schema",
+    required: ["entry", "tsconfig", "outputPath"],
+  },
+  entry: {
+    $schema: {
+      title: "Entry File(s)",
+      format: "path",
+      type: "array",
+      description: "The entry file or files to build",
+      items: { type: "string" },
+    },
+    $default: ["{sourceRoot}/index.ts"],
+  },
+  tsconfig: {
+    $schema: {
+      title: "TSConfig Path",
+      type: "string",
+      format: "path",
+      description: "The path to the tsconfig file",
+    },
+    $default: "{projectRoot}/tsconfig.json",
+  },
+  outputPath: {
+    $schema: {
+      title: "Output Path",
+      type: "string",
+      format: "path",
+      description: "The output path for the build",
+    },
+    $default: "{sourceRoot}/__generated__/typia",
+  },
+  clean: {
+    $schema: {
+      title: "Clean",
+      type: "boolean",
+      description: "Clean the output directory before building",
+    },
+    $default: true,
+  },
+});

package/src/executors/unbuild/executor.spec.ts

@@ -0,0 +1,11 @@
+import executor from "./executor";
+import { UnbuildExecutorSchema } from "./schema.d";
+
+const options: UnbuildExecutorSchema = {};
+
+describe("Unbuild Executor", () => {
+  it("can run", async () => {
+    const output = await executor(options);
+    expect(output.success).toBe(true);
+  });
+});

package/src/executors/unbuild/executor.ts

@@ -0,0 +1,136 @@
+import type { ExecutorContext } from "@nx/devkit";
+import type { StormWorkspaceConfig } from "@storm-software/config";
+import { writeInfo } from "@storm-software/config-tools/logger/console";
+import { joinPaths } from "@storm-software/config-tools/utilities/correct-paths";
+import { UnbuildOptions } from "@storm-software/unbuild";
+import { defu } from "defu";
+import { createJiti } from "jiti";
+import { withRunExecutor } from "../../base/base-executor";
+import type { UnbuildExecutorSchema } from "./schema.d";
+
+type StormUnbuildModule = {
+  build: (opts: UnbuildOptions) => Promise<void>;
+};
+
+export async function unbuildExecutorFn(
+  options: UnbuildExecutorSchema,
+  context: ExecutorContext,
+  config: StormWorkspaceConfig
+) {
+  writeInfo("📦  Running Storm Unbuild executor on the workspace", config);
+
+  // #region Prepare build context variables
+
+  if (
+    !context.projectsConfigurations?.projects ||
+    !context.projectName ||
+    !context.projectsConfigurations.projects[context.projectName]
+  ) {
+    throw new Error(
+      "The Build process failed because the context is not valid. Please run this command from a workspace root directory."
+    );
+  }
+
+  if (!context.projectsConfigurations.projects[context.projectName]!.root) {
+    throw new Error(
+      "The Build process failed because the project root is not valid. Please run this command from a workspace root directory."
+    );
+  }
+
+  if (
+    !context.projectsConfigurations.projects[context.projectName]!.sourceRoot
+  ) {
+    throw new Error(
+      "The Build process failed because the project's source root is not valid. Please run this command from a workspace root directory."
+    );
+  }
+
+  const jiti = createJiti(config.workspaceRoot, {
+    fsCache: config.skipCache
+      ? false
+      : joinPaths(
+          config.workspaceRoot,
+          config.directories.cache || "node_modules/.cache/storm",
+          "jiti"
+        ),
+    interopDefault: true
+  });
+
+  const stormUnbuild = await jiti.import<StormUnbuildModule>(
+    jiti.esmResolve("@storm-software/unbuild/build")
+  );
+
+  // #endregion Prepare build context variables
+
+  await stormUnbuild.build(
+    defu(
+      {
+        ...options,
+        projectRoot:
+          context.projectsConfigurations.projects![context.projectName]!.root,
+        projectName: context.projectName,
+        sourceRoot:
+          context.projectsConfigurations.projects![context.projectName]!
+            .sourceRoot,
+        platform: options.platform as UnbuildOptions["platform"]
+      },
+      {
+        stubOptions: {
+          jiti: {
+            fsCache: config.skipCache
+              ? false
+              : joinPaths(
+                  config.workspaceRoot,
+                  config.directories.cache || "node_modules/.cache/storm",
+                  "jiti"
+                )
+          }
+        },
+        rollup: {
+          emitCJS: true,
+          watch: false,
+          dts: {
+            respectExternal: true
+          },
+          esbuild: {
+            target: options.target,
+            format: "esm",
+            platform: options.platform,
+            minify: options.minify ?? !options.debug,
+            sourcemap: options.sourcemap ?? options.debug,
+            treeShaking: options.treeShaking
+          }
+        }
+      }
+    ) as UnbuildOptions
+  );
+
+  // #endregion Run the build process
+
+  return {
+    success: true
+  };
+}
+
+export default withRunExecutor<UnbuildExecutorSchema>(
+  "TypeScript Unbuild build",
+  unbuildExecutorFn,
+  {
+    skipReadingConfig: false,
+    hooks: {
+      applyDefaultOptions: async (
+        options: UnbuildExecutorSchema,
+        config?: StormWorkspaceConfig | undefined
+      ) => {
+        options.debug ??= false;
+        options.treeShaking ??= true;
+        options.buildOnly ??= false;
+        options.platform ??= "neutral";
+        options.entry ??= ["{sourceRoot}"];
+        options.tsconfig ??= "{projectRoot}/tsconfig.json";
+
+        return options;
+      }
+    }
+  }
+);

package/src/executors/unbuild/untyped.ts

@@ -0,0 +1,152 @@
+import { defineUntypedSchema } from "untyped";
+import typescriptBuildExecutorSchema from "../../base/typescript-build-executor.untyped";
+
+export default defineUntypedSchema({
+  ...typescriptBuildExecutorSchema,
+  $schema: {
+    id: "UnbuildExecutorSchema",
+    title: "Unbuild Executor",
+    description: "A type definition for a unbuild executor schema",
+    required: ["name", "entry"]
+  },
+  name: {
+    $schema: {
+      title: "Name",
+      type: "string",
+      description: "The name of the project/build"
+    },
+    $default: "{projectName}"
+  },
+  entry: {
+    $schema: {
+      title: "Input Directory",
+      format: "path",
+      type: "array",
+      description: "The directory to use as input for the build",
+      items: { type: "string" }
+    },
+    $default: ["{sourceRoot}"]
+  },
+  outputPath: {
+    $schema: {
+      title: "Output Path",
+      type: "string",
+      format: "path",
+      description: "The output path for the build"
+    }
+  },
+  treeShaking: {
+    $schema: {
+      title: "Tree Shaking",
+      type: "boolean",
+      description: "Enable tree shaking"
+    },
+    $default: true
+  },
+  watch: {
+    $schema: {
+      title: "Watch",
+      type: "boolean",
+      description: "Watch for changes"
+    },
+    $default: false
+  },
+  clean: {
+    $schema: {
+      title: "Clean",
+      type: "boolean",
+      description: "Clean the output directory before building"
+    },
+    $default: true
+  },
+  stub: {
+    $schema: {
+      title: "Stub",
+      type: "boolean",
+      description: "Stub the output"
+    },
+    $default: false
+  },
+  buildOnly: {
+    $schema: {
+      title: "Build Only",
+      type: "boolean",
+      description:
+        "Should the build process skip generating a package.json and copying assets"
+    },
+    $default: false
+  },
+  watchOptions: {
+    $schema: {
+      title: "Watch Options",
+      type: "object",
+      description: "Watch options"
+    },
+    $default: {}
+  },
+  stubOptions: {
+    $schema: {
+      title: "Stub Options",
+      type: "object",
+      description: "Stub options"
+    },
+    $default: {
+      jiti: {
+        cache: "node_modules/.cache/storm"
+      }
+    }
+  },
+  dependencies: {
+    $schema: {
+      title: "Dependencies",
+      type: "array",
+      description: "The dependencies to install",
+      items: {
+        type: "string"
+      }
+    }
+  },
+  peerDependencies: {
+    $schema: {
+      title: "Peer Dependencies",
+      type: "array",
+      description: "The peer dependencies to install",
+      items: {
+        type: "string"
+      }
+    }
+  },
+  devDependencies: {
+    $schema: {
+      title: "Dev Dependencies",
+      type: "array",
+      description: "The dev dependencies to install",
+      items: {
+        type: "string"
+      }
+    }
+  },
+  alias: {
+    $schema: {
+      title: "Alias",
+      type: "object",
+      tsType: "Record<string, string>",
+      description: "The alias to use"
+    }
+  },
+  replace: {
+    $schema: {
+      title: "Replace",
+      type: "object",
+      tsType: "Record<string, string>",
+      description: "The replace to use"
+    }
+  },
+  rollup: {
+    $schema: {
+      title: "Rollup",
+      type: "object",
+      description: "The rollup options"
+    }
+  }
+});

package/src/generators/browser-library/generator.spec.ts

@@ -0,0 +1,20 @@
+import { Tree, readProjectConfiguration } from "@nx/devkit";
+import { createTreeWithEmptyWorkspace } from "@nx/devkit/testing";
+
+import { browserLibraryGenerator } from "./generator";
+import { BrowserLibraryGeneratorSchema } from "./schema.d";
+
+describe("browser-library generator", () => {
+  let tree: Tree;
+  const options: BrowserLibraryGeneratorSchema = { name: "test" };
+
+  beforeEach(() => {
+    tree = createTreeWithEmptyWorkspace();
+  });
+
+  it("should run successfully", async () => {
+    await browserLibraryGenerator(tree, options);
+    const config = readProjectConfiguration(tree, "test");
+    expect(config).toBeDefined();
+  });
+});