@storm-software/k8s-tools 0.0.1

package/packages/workspace-tools/src/executors/tsup-browser/executor.d.ts

@@ -0,0 +1,8 @@
+import type { ExecutorContext } from "@nx/devkit";
+import { StormConfig } from "@storm-software/config";
+import type { TsupBrowserExecutorSchema } from "./schema.d";
+export declare const tsupBrowserBuildExecutorFn: (options: TsupBrowserExecutorSchema, context: ExecutorContext, config: StormConfig) => Promise<{
+    success: boolean;
+}>;
+declare const _default: import("@nx/devkit").PromiseExecutor<TsupBrowserExecutorSchema>;
+export default _default;

package/packages/workspace-tools/src/executors/tsup-neutral/executor.d.ts

@@ -0,0 +1,8 @@
+import type { ExecutorContext } from "@nx/devkit";
+import type { StormConfig } from "@storm-software/config";
+import type { TsupNeutralExecutorSchema } from "./schema";
+export declare const tsupNeutralBuildExecutorFn: (options: TsupNeutralExecutorSchema, context: ExecutorContext, config: StormConfig) => Promise<{
+    success: boolean;
+}>;
+declare const _default: import("@nx/devkit").PromiseExecutor<TsupNeutralExecutorSchema>;
+export default _default;

package/packages/workspace-tools/src/executors/tsup-node/executor.d.ts

@@ -0,0 +1,8 @@
+import type { ExecutorContext } from "@nx/devkit";
+import { StormConfig } from "@storm-software/config";
+import type { TsupNodeExecutorSchema } from "./schema";
+export declare const tsupNodeBuildExecutorFn: (options: TsupNodeExecutorSchema, context: ExecutorContext, config: StormConfig) => Promise<{
+    success: boolean;
+}>;
+declare const _default: import("@nx/devkit").PromiseExecutor<TsupNodeExecutorSchema>;
+export default _default;

package/packages/workspace-tools/src/executors/typia/executor.d.ts

@@ -0,0 +1,8 @@
+import type { ExecutorContext } from "@nx/devkit";
+import type { StormConfig } from "@storm-software/config";
+import type { TypiaExecutorSchema } from "./schema";
+export declare function typiaExecutorFn(options: TypiaExecutorSchema, _: ExecutorContext, config: StormConfig): Promise<{
+    success: boolean;
+}>;
+declare const _default: import("@nx/devkit").PromiseExecutor<TypiaExecutorSchema>;
+export default _default;

package/packages/workspace-tools/src/executors/unbuild/executor.d.ts

@@ -0,0 +1,9 @@
+import type { ExecutorContext } from "@nx/devkit";
+import type { UnbuildBuildOptions } from "@storm-software/build-tools";
+import type { StormConfig } from "@storm-software/config";
+import type { UnbuildExecutorSchema } from "./schema.d";
+export declare function unbuildExecutorFn(options: UnbuildExecutorSchema, context: ExecutorContext, config: StormConfig): Promise<{
+    success: boolean;
+}>;
+declare const _default: import("@nx/devkit").PromiseExecutor<UnbuildBuildOptions>;
+export default _default;

package/packages/workspace-tools/src/generators/config-schema/generator.d.ts

@@ -0,0 +1,13 @@
+import { type Tree } from "@nx/devkit";
+import { type StormConfig } from "@storm-software/config";
+import * as z from "zod";
+import type { ConfigSchemaGeneratorSchema } from "./schema";
+export type ModuleSchema = {
+    name: string;
+    schema: z.ZodObject<any>;
+};
+export declare function configSchemaGeneratorFn(tree: Tree, options: ConfigSchemaGeneratorSchema, config?: StormConfig): Promise<{
+    success: boolean;
+}>;
+declare const _default: (tree: Tree, _options: ConfigSchemaGeneratorSchema) => Promise<import("@nx/devkit").GeneratorCallback | import("../../../declarations").BaseGeneratorResult>;
+export default _default;

package/packages/workspace-tools/src/generators/init/init.d.ts

@@ -0,0 +1,4 @@
+import { type Tree } from "@nx/devkit";
+import type { Schema } from "./schema";
+export declare function initGenerator(tree: Tree, schema: Schema): Promise<import("@nx/devkit").GeneratorCallback>;
+export default initGenerator;

package/packages/workspace-tools/src/generators/node-library/generator.d.ts

@@ -0,0 +1,5 @@
+import { type Tree } from "@nx/devkit";
+import type { NodeLibraryGeneratorSchema } from "./schema";
+export declare function nodeLibraryGeneratorFn(tree: Tree, schema: NodeLibraryGeneratorSchema): Promise<null>;
+declare const _default: (tree: Tree, _options: NodeLibraryGeneratorSchema) => Promise<import("@nx/devkit").GeneratorCallback | import("../../../declarations.d").BaseGeneratorResult>;
+export default _default;

package/packages/workspace-tools/src/generators/preset/generator.d.ts

@@ -0,0 +1,5 @@
+import { type Tree } from "@nx/devkit";
+import type { PresetGeneratorSchema } from "./schema";
+export declare function presetGeneratorFn(tree: Tree, options: PresetGeneratorSchema): Promise<null>;
+declare const _default: (tree: Tree, _options: PresetGeneratorSchema) => Promise<import("@nx/devkit").GeneratorCallback | import("../../../declarations").BaseGeneratorResult>;
+export default _default;

package/packages/workspace-tools/src/generators/release-version/generator.d.ts

@@ -0,0 +1,13 @@
+import { NxReleaseConfig } from "nx/src/command-line/release/config/config";
+import { type VersionData } from "nx/src/command-line/release/version";
+import { type Tree } from "@nx/devkit";
+import type { StormConfig } from "@storm-software/config";
+import type { ReleaseVersionGeneratorSchema } from "./schema";
+export declare function releaseVersionGeneratorFn(tree: Tree, options: ReleaseVersionGeneratorSchema, config?: StormConfig): Promise<{
+    data: VersionData;
+    callback: (tree: any, opts: any) => Promise<string[]>;
+    success: boolean;
+}>;
+declare const _default: (tree: Tree, _options: ReleaseVersionGeneratorSchema) => Promise<import("@nx/devkit").GeneratorCallback | import("../../../declarations").BaseGeneratorResult>;
+export default _default;
+export declare const DEFAULT_CONVENTIONAL_COMMITS_CONFIG: NxReleaseConfig["conventionalCommits"];

package/packages/workspace-tools/src/utils/apply-workspace-tokens.d.ts

@@ -0,0 +1,8 @@
+import type { ProjectConfiguration } from "@nx/devkit";
+import type { BaseTokenizerOptions } from "@storm-software/config-tools";
+export type ExecutorTokenizerOptions = BaseTokenizerOptions & ProjectConfiguration & {
+    projectName: string;
+    projectRoot: string;
+    sourceRoot: string;
+};
+export declare const applyWorkspaceExecutorTokens: (option: string, tokenizerOptions: ExecutorTokenizerOptions) => Promise<string>;

package/packages/workspace-tools/src/utils/cargo.d.ts

@@ -0,0 +1,26 @@
+import { type ChildProcess, type StdioOptions } from "node:child_process";
+import type { CargoMetadata, Dependency, Package } from "./toml";
+interface CargoRun {
+    success: boolean;
+    output: string;
+}
+interface RunCargoOptions {
+    stdio: StdioOptions;
+    env: NodeJS.ProcessEnv | undefined;
+}
+export declare let childProcess: ChildProcess | null;
+export declare function cargoCommand(...args: string[]): Promise<{
+    success: boolean;
+}>;
+export declare function cargoRunCommand(...args: string[]): Promise<{
+    success: boolean;
+}>;
+export declare function cargoCommandSync(args?: string, options?: Partial<RunCargoOptions>): CargoRun;
+export declare function cargoMetadata(): CargoMetadata | null;
+export declare function isExternal(packageOrDep: Package | Dependency, workspaceRoot: string): any;
+export declare function runProcess(processCmd: string, ...args: string[]): {
+    success: boolean;
+} | PromiseLike<{
+    success: boolean;
+}>;
+export {};

package/packages/workspace-tools/src/utils/create-cli-options.d.ts

@@ -0,0 +1 @@
+export declare function createCliOptions<T extends Record<string, string | number | boolean | string[]>>(obj: T): string[];

package/packages/workspace-tools/src/utils/get-project-configurations.d.ts

@@ -0,0 +1,13 @@
+import type { ProjectConfiguration } from "@nx/devkit";
+/**
+ * Retrieve the project configurations from the workspace.
+ *
+ * @returns The project configurations.
+ */
+export declare const getProjectConfigurations: <TConfig extends ProjectConfiguration = ProjectConfiguration>() => Promise<Record<string, TConfig>>;
+/**
+ * Retrieve the project configurations from the workspace.
+ *
+ * @returns The project configurations.
+ */
+export declare const getProjectConfiguration: <TConfig extends ProjectConfiguration = ProjectConfiguration>(projectName: string) => TConfig | undefined;

package/packages/workspace-tools/src/utils/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./apply-workspace-tokens";
+export * from "./get-project-configurations";
+export * from "./typia-transform";
+export * from "./versions";
+export * from "./toml";
+export * from "./cargo";
+export * from "./lock-file";
+export * from "./create-cli-options";
+export * from "./project-tags";

package/packages/workspace-tools/src/utils/lock-file.d.ts

@@ -0,0 +1,23 @@
+import { type RawProjectGraphDependency, type CreateDependenciesContext, type CreateNodesContext, type PackageManager, type ProjectGraphExternalNode } from "nx/src/devkit-exports";
+export declare const YARN_LOCK_FILE = "yarn.lock";
+export declare const NPM_LOCK_FILE = "package-lock.json";
+export declare const PNPM_LOCK_FILE = "pnpm-lock.yaml";
+export declare const LOCK_FILES: string[];
+export declare const YARN_LOCK_PATH: string;
+export declare const NPM_LOCK_PATH: string;
+export declare const PNPM_LOCK_PATH: string;
+/**
+ * Parses lock file and maps dependencies and metadata to {@link LockFileGraph}
+ */
+export declare function getLockFileNodes(packageManager: PackageManager, contents: string, lockFileHash: string, context: CreateNodesContext): Record<string, ProjectGraphExternalNode>;
+/**
+ * Parses lock file and maps dependencies and metadata to {@link LockFileGraph}
+ */
+export declare function getLockFileDependencies(packageManager: PackageManager, contents: string, lockFileHash: string, context: CreateDependenciesContext): RawProjectGraphDependency[];
+export declare function lockFileExists(packageManager: PackageManager): boolean;
+/**
+ * Returns lock file name based on the detected package manager in the root
+ * @param packageManager
+ * @returns
+ */
+export declare function getLockFileName(packageManager: PackageManager): string;

package/packages/workspace-tools/src/utils/project-tags.d.ts

@@ -0,0 +1,30 @@
+import { ProjectConfiguration } from "@nx/devkit";
+import { ProjectTagDistStyleValue, ProjectTagLanguageValue, ProjectTagTypeValue, ProjectTagVariant } from "../../declarations.d";
+export declare const ProjectTagConstants: {
+    readonly Language: {
+        readonly TAG_ID: ProjectTagVariant;
+        readonly TYPESCRIPT: ProjectTagLanguageValue;
+        readonly RUST: ProjectTagLanguageValue;
+    };
+    readonly ProjectType: {
+        readonly TAG_ID: ProjectTagVariant;
+        readonly LIBRARY: ProjectTagTypeValue;
+        readonly APPLICATION: ProjectTagTypeValue;
+    };
+    readonly DistStyle: {
+        readonly TAG_ID: ProjectTagVariant;
+        readonly NORMAL: ProjectTagDistStyleValue;
+        readonly CLEAN: ProjectTagDistStyleValue;
+    };
+    readonly Provider: {
+        readonly TAG_ID: ProjectTagVariant;
+    };
+};
+export declare const formatProjectTag: (variant: ProjectTagVariant, value: string) => string;
+export declare const hasProjectTag: (project: ProjectConfiguration, variant: ProjectTagVariant) => boolean;
+export declare const getProjectTag: (project: ProjectConfiguration, variant: ProjectTagVariant) => string | undefined;
+export declare const isEqualProjectTag: (project: ProjectConfiguration, variant: ProjectTagVariant, value: string) => boolean;
+export declare const addProjectTag: (project: ProjectConfiguration, variant: ProjectTagVariant, value: string, options?: {
+    overwrite?: boolean;
+}) => void;
+export declare const setDefaultProjectTags: (project: ProjectConfiguration) => void;

package/packages/workspace-tools/src/utils/toml.d.ts

@@ -0,0 +1,167 @@
+import { type Tree } from "@nx/devkit";
+export interface CargoToml {
+    workspace?: {
+        members: string[];
+    };
+    package: any;
+    dependencies?: Record<string, string | {
+        version: string;
+        features?: string[];
+        optional?: boolean;
+    }>;
+    "dev-dependencies"?: Record<string, string | {
+        version: string;
+        features: string[];
+    }>;
+    [key: string]: any;
+}
+export interface CargoMetadata {
+    packages: Package[];
+    workspace_members: string[];
+    resolve: Resolve;
+    target_directory: string;
+    version: number;
+    workspace_root: string;
+    metadata: Metadata2;
+}
+export interface Package {
+    name: string;
+    version: string;
+    id: string;
+    license: string;
+    license_file: string;
+    description: string;
+    source: any;
+    dependencies: Dependency[];
+    targets: Target[];
+    features: Features;
+    manifest_path: string;
+    metadata: Metadata;
+    /**
+     * From the docs:
+     * "List of registries to which this package may be published.
+     * Publishing is unrestricted if null, and forbidden if an empty array."
+     *
+     * Additional observation:
+     * false can be used by the end user but it will be converted to an empty
+     * array in the cargo metadata output.
+     */
+    publish: string[] | null;
+    authors: string[];
+    categories: string[];
+    default_run: any;
+    rust_version: string;
+    keywords: string[];
+    readme: string;
+    repository: string;
+    homepage: string;
+    documentation: string;
+    edition: string;
+    links: any;
+}
+export interface Dependency {
+    name: string;
+    source: string;
+    req: string;
+    kind: any;
+    rename: any;
+    optional: boolean;
+    uses_default_features: boolean;
+    features: any[];
+    target: string;
+    path: string;
+    registry: any;
+}
+export interface Target {
+    kind: string[];
+    crate_types: string[];
+    name: string;
+    src_path: string;
+    edition: string;
+    "required-features": string[];
+    doc: boolean;
+    doctest: boolean;
+    test: boolean;
+}
+export interface Features {
+    default: string[];
+    feat1: any[];
+    feat2: any[];
+}
+export interface Metadata {
+    docs: Docs;
+}
+export interface Docs {
+    rs: Rs;
+}
+export interface Rs {
+    "all-features": boolean;
+}
+export interface Resolve {
+    nodes: Node[];
+    root: string;
+}
+export interface Node {
+    id: string;
+    dependencies: string[];
+    deps: Dep[];
+    features: string[];
+}
+export interface Dep {
+    name: string;
+    pkg: string;
+    dep_kinds: DepKind[];
+}
+export interface DepKind {
+    kind: any;
+    target: string;
+}
+export interface Metadata2 {
+    docs: Docs2;
+}
+export interface Docs2 {
+    rs: Rs2;
+}
+export interface Rs2 {
+    "all-features": boolean;
+}
+export interface Package {
+    name: string;
+    version: string;
+    id: string;
+    license: string;
+    license_file: string;
+    description: string;
+    source: any;
+    dependencies: Dependency[];
+    targets: Target[];
+    features: Features;
+    manifest_path: string;
+    metadata: Metadata;
+    /**
+     * From the docs:
+     * "List of registries to which this package may be published.
+     * Publishing is unrestricted if null, and forbidden if an empty array."
+     *
+     * Additional observation:
+     * false can be used by the end user but it will be converted to an empty
+     * array in the cargo metadata output.
+     */
+    publish: string[] | null;
+    authors: string[];
+    categories: string[];
+    default_run: any;
+    rust_version: string;
+    keywords: string[];
+    readme: string;
+    repository: string;
+    homepage: string;
+    documentation: string;
+    edition: string;
+    links: any;
+}
+export declare function parseCargoTomlWithTree(tree: Tree, projectRoot: string, projectName: string): CargoToml;
+export declare function parseCargoToml(cargoString?: string): CargoToml;
+export declare function stringifyCargoToml(cargoToml: CargoToml): string;
+export declare function modifyCargoTable(toml: CargoToml, section: string, key: string, value: string | object | any[] | (() => any)): void;
+export declare function modifyCargoNestedTable(toml: CargoToml, section: string, key: string, value: object): void;

package/packages/workspace-tools/src/utils/typia-transform.d.ts

@@ -0,0 +1,2 @@
+import type ts from "typescript";
+export declare const getTypiaTransform: (program: ts.Program, diagnostics: ts.Diagnostic[]) => ts.TransformerFactory<ts.SourceFile>;

package/packages/workspace-tools/src/utils/versions.d.ts

@@ -0,0 +1,18 @@
+export declare const tsupVersion = "^7.2.0";
+export declare const prettierPackageJsonVersion = "2.4.6";
+export declare const prettierPrismaVersion = "5.0.0";
+export declare const prettierVersion = "^3.0.3";
+export declare const swcCliVersion = "~0.1.62";
+export declare const swcCoreVersion = "~1.3.95";
+export declare const swcHelpersVersion = "~0.5.3";
+export declare const swcNodeVersion = "1.6.8";
+export declare const tsLibVersion = "2.6.2";
+export declare const typesNodeVersion = "20.9.0";
+export declare const verdaccioVersion = "5.27.0";
+export declare const typescriptVersion = "~5.2.2";
+export declare const eslintVersion = "~8.53.0";
+export declare const lintStagedVersion = "15.0.2";
+export declare const semanticReleaseVersion = "22.0.7";
+export declare const nxVersion = "^18.0.4";
+export declare const nodeVersion = "20.11.0";
+export declare const pnpmVersion = "8.10.2";