stack-dev 0.1.0

package/apps/cli/src/link-packages.ts

@@ -0,0 +1,65 @@
+import { Dependency, PackageJSON } from './package-json';
+import { getDirectoryPackageJson, getPackageJSONPath } from './utils/utils';
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { TSConfig } from './tsconfig';
+import { Package } from './utils/package';
+import { getNamespace } from './utils/workspace';
+
+export async function linkPackages(
+  current: Package,
+  target: Package,
+  development: boolean,
+): Promise<void> {
+  await updatePackageJSON(current, target, development);
+  await updateTSConfig(current, target);
+}
+
+async function updatePackageJSON(
+  current: Package,
+  target: Package,
+  development: boolean,
+) {
+  const namespace = await getNamespace();
+
+  const packageJSON = await getDirectoryPackageJson(current.directory);
+  const updated = addDependency(packageJSON, target, development);
+
+  const packageJSONPath = getPackageJSONPath(current.directory);
+
+  await fs.writeFile(packageJSONPath, updated.format(namespace));
+}
+
+function addDependency(
+  packageJSON: PackageJSON,
+  target: Package,
+  development: boolean,
+): PackageJSON {
+  const dependency = new Dependency(target.name, 'workspace:*');
+
+  if (development) {
+    return packageJSON.addDevDependency(dependency);
+  } else {
+    return packageJSON.addDependency(dependency);
+  }
+}
+
+async function updateTSConfig(current: Package, target: Package) {
+  const tsconfigPath = path.join(current.directory, 'tsconfig.json');
+  const tsconfigContents = await fs.readFile(tsconfigPath, 'utf8');
+  const tsconfig = TSConfig.parse(tsconfigContents);
+
+  const targetDirectory = path.join(target.directory, 'src', 'index.ts');
+
+  const updatedPaths = {
+    ...tsconfig.compilerOptions.paths,
+    [target.name]: [path.relative(current.directory, targetDirectory)],
+  };
+  const updatedCompilerOptions =
+    tsconfig.compilerOptions.setPaths(updatedPaths);
+
+  const updated = tsconfig.setCompilerOptions(updatedCompilerOptions);
+
+  await fs.writeFile(tsconfigPath, updated.format());
+}

package/apps/cli/src/package-json/dependency.ts

@@ -0,0 +1,28 @@
+import { Equalable } from '@stack-dev/core';
+
+export class Dependency implements Equalable {
+  private readonly _name: string;
+
+  private readonly _version: string;
+
+  public constructor(name: string, version: string) {
+    this._name = name;
+    this._version = version;
+  }
+
+  public get name(): string {
+    return this._name;
+  }
+
+  public get version(): string {
+    return this._version;
+  }
+
+  public equals(other: unknown): boolean {
+    if (other instanceof Dependency) {
+      return this._name === other._name && this._version === other._version;
+    } else {
+      return false;
+    }
+  }
+}

package/apps/cli/src/package-json/index.ts

@@ -0,0 +1,3 @@
+export * from './package-json';
+
+export * from './dependency';

package/apps/cli/src/package-json/package-json.ts

@@ -0,0 +1,269 @@
+import { Equalable, haveSameItems, sortKeys } from '@stack-dev/core';
+
+import { Snapshot } from '@stack-dev/core';
+import JSON5 from 'json5';
+import { isEqual } from 'lodash';
+import { Dependency } from './dependency';
+
+export type ConstructorArgs = {
+  name: string;
+  dependencies?: ReadonlyArray<Dependency>;
+  devDependencies?: ReadonlyArray<Dependency>;
+  peerDependencies?: ReadonlyArray<Dependency>;
+  additionalData?: Snapshot;
+};
+
+export class PackageJSON implements Equalable {
+  private readonly _name: string;
+
+  private readonly _dependencies: ReadonlyArray<Dependency>;
+
+  private readonly _devDependencies: ReadonlyArray<Dependency>;
+
+  private readonly _peerDependencies: ReadonlyArray<Dependency>;
+
+  private readonly _additionalData: Snapshot;
+
+  public constructor(args: ConstructorArgs) {
+    this._name = args.name;
+    this._dependencies = args.dependencies ?? [];
+    this._devDependencies = args.devDependencies ?? [];
+    this._peerDependencies = args.peerDependencies ?? [];
+    this._additionalData = args.additionalData ?? {};
+  }
+
+  public get name(): string {
+    return this._name;
+  }
+
+  public get dependencies(): ReadonlyArray<Dependency> {
+    return this._dependencies;
+  }
+
+  public get devDependencies(): ReadonlyArray<Dependency> {
+    return this._devDependencies;
+  }
+
+  public get peerDependencies(): ReadonlyArray<Dependency> {
+    return this._peerDependencies;
+  }
+
+  public addDependency(dependency: Dependency): PackageJSON {
+    return new PackageJSON({
+      name: this.name,
+      dependencies: [...this.dependencies, dependency],
+      devDependencies: this.devDependencies,
+      additionalData: this._additionalData,
+    });
+  }
+
+  public addDevDependency(dependency: Dependency): PackageJSON {
+    return new PackageJSON({
+      name: this.name,
+      dependencies: this.dependencies,
+      devDependencies: [...this.devDependencies, dependency],
+      additionalData: this._additionalData,
+    });
+  }
+
+  public addPeerDependency(dependency: Dependency): PackageJSON {
+    return new PackageJSON({
+      name: this.name,
+      dependencies: this.dependencies,
+      devDependencies: this.devDependencies,
+      peerDependencies: [...this.peerDependencies, dependency],
+      additionalData: this._additionalData,
+    })
+  }
+
+  public removeDependency(name: string): PackageJSON {
+    return new PackageJSON({
+      name: this.name,
+      dependencies: this.dependencies.filter((d) => d.name !== name),
+      devDependencies: this.devDependencies,
+      additionalData: this._additionalData,
+    });
+  }
+
+  public removeDevDependency(name: string): PackageJSON {
+    return new PackageJSON({
+      name: this.name,
+      dependencies: this.dependencies,
+      devDependencies: this.devDependencies.filter((d) => d.name !== name),
+      additionalData: this._additionalData,
+    });
+  }
+
+  public removePeerDependency(name: string): PackageJSON {
+    return new PackageJSON({
+      name: this.name,
+      dependencies: this.dependencies,
+      devDependencies: this.devDependencies,
+      peerDependencies: this.peerDependencies.filter((d) => d.name !== name),
+      additionalData: this._additionalData,
+    });
+  }
+
+  public static parse(s: string): PackageJSON {
+    const json = JSON5.parse(s);
+
+    const name = json.name;
+    const dependencies = PackageJSON.parseDependencies(json);
+    const devDependencies = PackageJSON.parseDevDependencies(json);
+    const peerDependencies = PackageJSON.parsePeerDependencies(json);
+
+    const additionalData = { ...json };
+    delete additionalData['name'];
+    delete additionalData['dependencies'];
+    delete additionalData['devDependencies'];
+    delete additionalData['peerDependencies'];
+
+    return new PackageJSON({
+      name,
+      dependencies,
+      devDependencies,
+      peerDependencies,
+      additionalData,
+    });
+  }
+
+  private static parseDependencies(json: Snapshot) {
+    if ('dependencies' in json && typeof json.dependencies === 'object') {
+      return Object.entries(json.dependencies).map(
+        ([name, version]) => new Dependency(name, version as string),
+      );
+    } else {
+      return [];
+    }
+  }
+
+  private static parseDevDependencies(json: Snapshot) {
+    if ('devDependencies' in json && typeof json.devDependencies === 'object') {
+      return Object.entries(json.devDependencies).map(
+        ([name, version]) => new Dependency(name, version as string),
+      );
+    } else {
+      return [];
+    }
+  }
+
+  private static parsePeerDependencies(json: Snapshot) {
+    if ('peerDependencies' in json && typeof json.peerDependencies === 'object') {
+      return Object.entries(json.peerDependencies).map(
+        ([name, version]) => new Dependency(name, version as string),
+      );
+    } else {
+      return [];
+    }
+  }
+
+  public format(namespace: string): string {
+    const json = {
+      name: this._name,
+      dependencies: makeDependencyObject(this._dependencies, namespace),
+      devDependencies: makeDependencyObject(this._devDependencies, namespace),
+      peerDependencies: makeDependencyObject(this._peerDependencies, namespace),
+      ...this._additionalData,
+    };
+
+    const ordered = sortKeys(json, comparePackageJSONKeys);
+
+    return JSON.stringify(ordered, null, 2);
+  }
+
+  public equals(other: unknown): boolean {
+    if (other instanceof PackageJSON) {
+      const sameDependencies = haveSameItems(
+        this._dependencies,
+        other._dependencies,
+        (d1, d2) => d1.equals(d2),
+      );
+
+      const sameDevDependencies = haveSameItems(
+        this._devDependencies,
+        other._devDependencies,
+        (d1, d2) => d1.equals(d2),
+      );
+
+      const samePeerDependencies = haveSameItems(
+        this._peerDependencies,
+        other._peerDependencies,
+        (d1, d2) => d1.equals(d2),
+      )
+
+      return (
+        this._name === other._name &&
+        sameDependencies &&
+        sameDevDependencies &&
+        samePeerDependencies &&
+        isEqual(this._additionalData, other._additionalData)
+      );
+    } else {
+      return false;
+    }
+  }
+}
+
+function makeDependencyObject(
+  dependencies: ReadonlyArray<Dependency>,
+  namespace: string,
+): Record<string, string> | undefined {
+  if (dependencies.length === 0) {
+    return undefined;
+  }
+
+  const result: Record<string, string> = {};
+
+  dependencies
+    .toSorted((a, b) => comparePackageNames(a.name, b.name, namespace))
+    .forEach((d) => (result[d.name] = d.version));
+
+  return result;
+}
+
+function comparePackageNames(a: string, b: string, namespace: string): number {
+  if (a.startsWith(namespace) && b.startsWith(namespace)) {
+    return a.localeCompare(b);
+  } else if (a.startsWith(namespace)) {
+    return -1;
+  } else if (b.startsWith(namespace)) {
+    return 1;
+  } else {
+    return a.localeCompare(b);
+  }
+}
+
+function comparePackageJSONKeys(a: string, b: string): number {
+  return getKeyIndex(a) - getKeyIndex(b);
+}
+
+function getKeyIndex(s: string): number {
+  switch (s.toLowerCase()) {
+    case 'name':
+      return 0;
+    case 'version':
+      return 1;
+    case 'private':
+      return 2;
+    case 'bin':
+      return 3;
+    case 'main':
+      return 4;
+    case 'module':
+      return 5;
+    case 'types':
+      return 6;
+    case 'exports':
+      return 7;
+    case 'scripts':
+      return 8;
+    case 'dependencies':
+      return 9;
+    case 'devDependencies':
+      return 10;
+    case 'peerdependencies':
+      return 11;
+    default:
+      return Number.MAX_VALUE;
+  }
+}

package/apps/cli/src/packages/create-config-package.ts

@@ -0,0 +1,29 @@
+import path from 'node:path';
+import { PackageJSON } from '../package-json';
+import { PackageJsonGenerator } from '../file-generator';
+import { PackageGenerator } from '../utils/package-generator';
+import { getNamespace, getWorkspaceRoot } from '../utils/workspace';
+
+export async function createConfigPackage(name: string): Promise<void> {
+  const rootDir = await getWorkspaceRoot();
+  const directory = path.join(rootDir, 'configs', name);
+
+  const namespace = await getNamespace(rootDir);
+  const packageName = `${namespace}/${name}`;
+
+  const packageJsonModel = new PackageJSON({
+    name: packageName,
+    additionalData: {
+      version: '0.1.0',
+      private: true,
+    },
+  });
+
+  const generator = new PackageGenerator(
+    directory,
+    new PackageJsonGenerator(packageJsonModel, namespace),
+    [],
+  );
+
+  await generator.generate();
+}

package/apps/cli/src/packages/index.ts

@@ -0,0 +1,4 @@
+export * from './library-package';
+export * from './react-package';
+
+export * from './create-config-package';

package/apps/cli/src/packages/library-package/create-library-package.ts

@@ -0,0 +1,85 @@
+import { getNamespace, getWorkspaceRoot } from '../../utils/workspace';
+
+import path from 'node:path';
+import { PackageJsonGenerator } from '../../file-generator';
+import { Dependency, PackageJSON } from '../../package-json';
+import { PackageGenerator } from '../../utils/package-generator';
+import { ADD_FILE_GENERATOR } from './files/add-file-generator';
+import { ADD_SPEC_FILE_GENERATOR } from './files/add-spec-file-generator';
+import { ESLINT_CONFIG_FILE_GENERATOR } from './files/eslint-config-file-generator';
+import { INDEX_FILE_GENERATOR } from './files/index-file-generator';
+import { PRETTIER_CONFIG_FILE_GENERATOR } from './files/prettier-config-file-generator';
+import { TSCONFIG_FILE_GENERATOR } from './files/tsconfig-file-generator';
+import { TSUP_CONFIG_FILE_GENERATOR } from './files/tsup-config-file-generator';
+import { VITEST_CONFIG_FILE_GENERATOR } from './files/vitest-config-file-generator';
+
+export async function createLibraryPackage(name: string): Promise<void> {
+  const rootDir = await getWorkspaceRoot();
+  const directory = path.join(rootDir, 'packages', name);
+
+  const namespace = await getNamespace(rootDir);
+  const packageName = `${namespace}/${name}`;
+
+  console.log(`✨ Creating config package: ${packageName}`);
+
+  const generator = new PackageGenerator(
+    directory,
+    makePackageGenerator(packageName, namespace),
+    [
+      INDEX_FILE_GENERATOR,
+      ADD_FILE_GENERATOR,
+      ADD_SPEC_FILE_GENERATOR,
+      TSUP_CONFIG_FILE_GENERATOR,
+      TSCONFIG_FILE_GENERATOR,
+      PRETTIER_CONFIG_FILE_GENERATOR,
+      ESLINT_CONFIG_FILE_GENERATOR,
+      VITEST_CONFIG_FILE_GENERATOR,
+    ],
+  );
+
+  await generator.generate();
+
+  console.log(`✅ Config package created at: ${directory}`);
+}
+
+function makePackageGenerator(packageName: string, namespace: string) {
+  const packageJsonModel = new PackageJSON({
+    name: packageName,
+    devDependencies: [
+      new Dependency(`${namespace}/eslint-config`, 'workspace:*'),
+      new Dependency(`${namespace}/prettier-config`, 'workspace:*'),
+      new Dependency(`${namespace}/typescript-config`, 'workspace:*'),
+      new Dependency('eslint', '^9.32.0'),
+      new Dependency('prettier', '^3.6.2'),
+      new Dependency('prettier-plugin-organize-imports', '^4.2.0'),
+      new Dependency('tsup', '^7.3.0'),
+      new Dependency('vitest', '^3.2.4'),
+      new Dependency('@vitest/coverage-v8', '^3.2.4'),
+    ],
+    additionalData: {
+      version: '0.1.0',
+      private: true,
+      main: 'dist/index.js',
+      module: 'dist/index.mjs',
+      types: 'dist/index.d.ts',
+      exports: {
+        '.': {
+          development: './src/index.ts',
+          import: './dist/index.mjs',
+          require: './dist/index.js',
+          types: './dist/index.d.ts',
+        },
+      },
+      scripts: {
+        build: 'tsup',
+        lint: 'eslint',
+        format: 'prettier . --write',
+        test: 'vitest run',
+        'test:watch': 'vitest',
+      },
+      sideEffects: false,
+    },
+  });
+
+  return new PackageJsonGenerator(packageJsonModel, namespace);
+}

package/apps/cli/src/packages/library-package/files/add-file-generator.ts

@@ -0,0 +1,8 @@
+import { FileGeneratorImp } from '../../../file-generator/file-generator-imp';
+
+const ADD_TS = `export function add(n1: number, n2: number): number {
+  return n1 + n2;
+}
+`;
+
+export const ADD_FILE_GENERATOR = new FileGeneratorImp('src/add.ts', ADD_TS);

package/apps/cli/src/packages/library-package/files/add-spec-file-generator.ts

@@ -0,0 +1,17 @@
+import { FileGeneratorImp } from '../../../file-generator/file-generator-imp';
+
+const ADD_SPEC_TS = `import { describe, it, expect } from 'vitest';
+
+import { add } from '../add';
+
+describe('add', () => {
+  it('adds two numbers', () => {
+    expect(add(2, 3)).toBe(5);
+  });
+});
+`;
+
+export const ADD_SPEC_FILE_GENERATOR = new FileGeneratorImp(
+  'src/spec/add.spec.ts',
+  ADD_SPEC_TS,
+);

package/apps/cli/src/packages/library-package/files/eslint-config-file-generator.ts

@@ -0,0 +1,11 @@
+import { FileGeneratorImp } from '../../../file-generator/file-generator-imp';
+
+const ESLINT_CONFIG = `import base from '@stack-dev/eslint-config/base.mjs';
+
+export default [...base, { ignores: ['**/dist/**'] }];
+`;
+
+export const ESLINT_CONFIG_FILE_GENERATOR = new FileGeneratorImp(
+  'eslint.config.mjs',
+  ESLINT_CONFIG,
+);

package/apps/cli/src/packages/library-package/files/index-file-generator.ts

@@ -0,0 +1,9 @@
+import { FileGeneratorImp } from '../../../file-generator/file-generator-imp';
+
+const INDEX_TS = `export * from './add';
+`;
+
+export const INDEX_FILE_GENERATOR = new FileGeneratorImp(
+  'src/index.ts',
+  INDEX_TS,
+);

package/apps/cli/src/packages/library-package/files/prettier-config-file-generator.ts

@@ -0,0 +1,11 @@
+import { FileGeneratorImp } from '../../../file-generator/file-generator-imp';
+
+const PRETTIER_CONFIG = `import base from '@stack-dev/prettier-config/base.mjs';
+
+export default base;
+`;
+
+export const PRETTIER_CONFIG_FILE_GENERATOR = new FileGeneratorImp(
+  'prettier.config.mjs',
+  PRETTIER_CONFIG,
+);

package/apps/cli/src/packages/library-package/files/tsconfig-file-generator.ts

@@ -0,0 +1,15 @@
+import { FileGeneratorImp } from '../../../file-generator/file-generator-imp';
+
+const TSCONFIG = `{
+  "extends": "@stack-dev/typescript-config/tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist"
+  },
+  "include": ["src"]
+}
+`;
+
+export const TSCONFIG_FILE_GENERATOR = new FileGeneratorImp(
+  'tsconfig.json',
+  TSCONFIG,
+);

package/apps/cli/src/packages/library-package/files/tsup-config-file-generator.ts

@@ -0,0 +1,23 @@
+import { FileGeneratorImp } from '../../../file-generator/file-generator-imp';
+
+const TSUP_CONFIG = `import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['esm', 'cjs'],
+  dts: true,
+  sourcemap: true,
+  clean: true,
+  target: 'esnext',
+  outExtension({ format }) {
+    return {
+      js: format === 'esm' ? '.mjs' : '.js',
+    };
+  },
+});
+`;
+
+export const TSUP_CONFIG_FILE_GENERATOR = new FileGeneratorImp(
+  'tsup.config.ts',
+  TSUP_CONFIG,
+);

package/apps/cli/src/packages/library-package/files/vitest-config-file-generator.ts

@@ -0,0 +1,19 @@
+import { FileGeneratorImp } from '../../../file-generator/file-generator-imp';
+
+const VITEST_CONFIG = `import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    coverage: {
+      provider: 'v8',
+    },
+    environment: 'node',
+  },
+});
+`;
+
+export const VITEST_CONFIG_FILE_GENERATOR = new FileGeneratorImp(
+  'vitest.config.ts',
+  VITEST_CONFIG,
+);

package/apps/cli/src/packages/library-package/index.ts

@@ -0,0 +1 @@
+export * from './create-library-package';

package/apps/cli/src/packages/react-package/create-react-package.ts

@@ -0,0 +1,25 @@
+import { StyleType } from '../../utils/style-type';
+import { createTailwindReactPackage } from './create-tailwind-react-package';
+import { createUnstyledReactPackage } from './create-unstyled-react-package';
+import { createCssReactPackage } from './css-react-package/create-css-react-package';
+import { createStyledComponentsReactPackage } from './styled-components-react-package/create-styled-components-react-package';
+
+export async function createReactPackage(
+  name: string,
+  style: StyleType,
+): Promise<void> {
+  switch (style) {
+    case 'tailwind':
+      await createTailwindReactPackage(name);
+      break;
+    case 'css-modules':
+      await createCssReactPackage(name);
+      break;
+    case 'styled-components':
+      await createStyledComponentsReactPackage(name);
+      break;
+    case 'none':
+      await createUnstyledReactPackage(name);
+      break;
+  }
+}

package/apps/cli/src/packages/react-package/create-tailwind-react-package.ts

@@ -0,0 +1,30 @@
+import { FileGeneratorImp } from "../../file-generator/file-generator-imp";
+
+export async function createTailwindReactPackage(name: string): Promise<void> {
+  throw new Error('Not implemented.');
+}
+
+const STYLED_BUTTON = `import React from 'react';
+
+interface ButtonProps {
+  label: string;
+  onClick?: () => void; 
+}
+
+export function TailwindButton(props: ButtonProps) {
+  const {label, onClick} = props;
+    
+  return (
+    <button 
+      onClick={onClick}
+      className="my-lib-bg-blue-600 my-lib-text-white my-lib-p-[10px] my-lib-border-none my-lib-rounded my-lib-cursor-pointer hover:my-lib-brightness-110"
+    >
+      {label}
+    </button>
+  );
+};`;
+
+export const STYLED_BUTTON_FILE_GENERATOR = new FileGeneratorImp(
+  'styled-button.ts',
+  STYLED_BUTTON,
+);

package/apps/cli/src/packages/react-package/create-unstyled-react-package.ts

@@ -0,0 +1,3 @@
+export async function createUnstyledReactPackage(name: string): Promise<void> {
+  throw new Error('Not implemented.');
+}