@storm-software/workspace-tools 1.270.2 → 1.271.0

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

@@ -1,56 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,88 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,136 +0,0 @@
-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

@@ -1,152 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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();
-  });
-});