npm - stack-dev - Versions diffs - 0.1.0 - Mend

stack-dev 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (204) hide show

package/apps/cli/src/packages/vite-react-app/files/app-file-generator.ts ADDED Viewed

@@ -0,0 +1,28 @@
+import { FileGeneratorImp } from '../../../file-generator/file-generator-imp';
+const APP = `import React, { useState } from 'react';
+export function App() {
+  const [count, setCount] = useState(0);
+  return (
+    <div style={{
+      padding: '2rem',
+      fontFamily: 'system-ui, sans-serif',
+      textAlign: 'center'
+    }}>
+      <h1>Stack-Dev App</h1>
+      <div className="card">
+        <button onClick={function() { setCount(count + 1) }}>
+          Count is {count}
+        </button>
+      </div>
+      <p>
+        Edit <code>src/App.tsx</code> and save to test HMR
+      </p>
+    </div>
+  );
+}
+`;
+export const APP_FILE_GENERATOR = new FileGeneratorImp('src/App.tsx', APP);

package/apps/cli/src/packages/vite-react-app/files/eslint-config-file-generator.ts ADDED Viewed

@@ -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/vite-react-app/files/index-html-file-generator.ts ADDED Viewed

@@ -0,0 +1,20 @@
+import { FileGeneratorImp } from '../../../file-generator/file-generator-imp';
+const INDEX_HTML = `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Vite + React + Stack-Dev</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>
+`;
+export const INDEX_HTML_FILE_GENERATOR = new FileGeneratorImp(
+  'index.html',
+  INDEX_HTML,
+);

package/apps/cli/src/packages/vite-react-app/files/main-file-generator.ts ADDED Viewed

@@ -0,0 +1,14 @@
+import { FileGeneratorImp } from '../../../file-generator/file-generator-imp';
+const MAIN = `import React from 'react';
+import ReactDOM from 'react-dom/client';
+import { App } from './App';
+ReactDOM.createRoot(document.getElementById('root')!).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>,
+);
+`;
+export const MAIN_FILE_GENERATOR = new FileGeneratorImp('src/main.tsx', MAIN);

package/apps/cli/src/packages/vite-react-app/files/prettier-config-file-generator.ts ADDED Viewed

@@ -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/vite-react-app/files/tsconfig-file-generator.ts ADDED Viewed

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

package/apps/cli/src/packages/vite-react-app/files/vite-config-file-generator.ts ADDED Viewed

@@ -0,0 +1,17 @@
+import { FileGeneratorImp } from '../../../file-generator/file-generator-imp';
+const VITE_CONFIG = `import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+export default defineConfig({
+  plugins: [react()],
+  server: {
+    port: 3000,
+  },
+});
+`;
+export const VITE_CONFIG_FILE_GENERATOR = new FileGeneratorImp(
+  'vite.config.ts',
+  VITE_CONFIG,
+);

package/apps/cli/src/packages/vite-react-app/files/vitest-config-file-generator.ts ADDED Viewed

@@ -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/tsconfig/compiler-options.ts ADDED Viewed

@@ -0,0 +1,83 @@
+import { Equalable, Snapshot, sortKeys } from '@stack-dev/core';
+import { isEqual } from 'lodash';
+export type ConstructorArgs = {
+  paths?: Record<string, ReadonlyArray<string>>;
+  additionalData?: Snapshot;
+};
+export class CompilerOptions implements Equalable {
+  private readonly _additionalData: Snapshot;
+  private readonly _paths: Record<string, ReadonlyArray<string>>;
+  public constructor(args?: ConstructorArgs) {
+    this._paths = args?.paths ?? {};
+    this._additionalData = args?.additionalData ?? {};
+  }
+  public get paths(): Record<string, ReadonlyArray<string>> {
+    return this._paths;
+  }
+  public get additionalData(): Snapshot {
+    return this._additionalData;
+  }
+  public setPaths(
+    paths: Record<string, ReadonlyArray<string>>,
+  ): CompilerOptions {
+    return new CompilerOptions({
+      paths,
+      additionalData: this._additionalData,
+    });
+  }
+  public format(): string {
+    const json = {
+      paths: this._paths,
+      ...this._additionalData,
+    };
+    const ordered = sortKeys(json, compareKeys);
+    return JSON.stringify(ordered, null, 2);
+  }
+  public equals(other: unknown): boolean {
+    // TODO: Get rid of lodash.
+    if (other instanceof CompilerOptions) {
+      return (
+        isEqual(this._paths, other._paths) &&
+        isEqual(this._additionalData, other._additionalData)
+      );
+    } else {
+      return false;
+    }
+  }
+}
+function compareKeys(a: string, b: string): number {
+  return getKeyIndex(a) - getKeyIndex(b);
+}
+function getKeyIndex(s: string): number {
+  const order = [
+    'target',
+    'module',
+    'moduleResolution',
+    'esModuleInterop',
+    'lib',
+    'types',
+    'strict',
+    'allowJs',
+  ];
+  if (order.every((key) => key !== s)) {
+    return Number.MAX_VALUE;
+  } else {
+    return order.indexOf(s);
+  }
+}

package/apps/cli/src/tsconfig/index.ts ADDED Viewed

@@ -0,0 +1,4 @@
+export * from './tsconfig';
+export * from './compiler-options';
+export * from './reference';

package/apps/cli/src/tsconfig/reference.ts ADDED Viewed

@@ -0,0 +1,21 @@
+import { Equalable } from '@stack-dev/core';
+export class Reference implements Equalable {
+  private readonly _path: string;
+  public constructor(path: string) {
+    this._path = path;
+  }
+  public get path(): string {
+    return this._path;
+  }
+  equals(other: unknown): boolean {
+    if (other instanceof Reference) {
+      return this._path === other._path;
+    } else {
+      return false;
+    }
+  }
+}

package/apps/cli/src/tsconfig/tsconfig.ts ADDED Viewed

@@ -0,0 +1,137 @@
+import * as JSON5 from 'json5';
+import { Equalable, haveSameItems, sortKeys } from '@stack-dev/core';
+import { Snapshot } from '@stack-dev/core';
+import { isEqual } from 'lodash';
+import { CompilerOptions } from './compiler-options';
+import { Reference } from './reference';
+type ConstructorArgs = {
+  compilerOptions?: CompilerOptions;
+  references?: ReadonlyArray<Reference>;
+  additionalData?: Snapshot;
+};
+export class TSConfig implements Equalable {
+  private readonly _compilerOptions: CompilerOptions;
+  private readonly _references: ReadonlyArray<Reference>;
+  private readonly _additionalData: Snapshot;
+  public constructor(args?: ConstructorArgs) {
+    this._compilerOptions = args?.compilerOptions ?? new CompilerOptions();
+    this._references = args?.references ?? [];
+    this._additionalData = args?.additionalData ?? {};
+  }
+  public get compilerOptions(): CompilerOptions {
+    return this._compilerOptions;
+  }
+  public addReference(reference: Reference): TSConfig {
+    return new TSConfig({
+      compilerOptions: this._compilerOptions,
+      references: [...this._references, reference],
+      additionalData: this._additionalData,
+    });
+  }
+  public setCompilerOptions(compilerOptions: CompilerOptions): TSConfig {
+    return new TSConfig({
+      compilerOptions,
+      references: this._references,
+      additionalData: this._additionalData,
+    });
+  }
+  public static parse(s: string): TSConfig {
+    const json = JSON5.parse(s);
+    const references = TSConfig.parseReferences(json);
+    const compilerOptions = new CompilerOptions({
+      paths: json.compilerOptions?.paths,
+      ...json.compilerOptions,
+    });
+    const additionalData = { ...json };
+    delete additionalData['compilerOptions'];
+    delete additionalData['references'];
+    return new TSConfig({
+      compilerOptions,
+      references,
+      additionalData,
+    });
+  }
+  private static parseReferences(json: unknown): ReadonlyArray<Reference> {
+    if (
+      typeof json === 'object' &&
+      json !== null &&
+      'references' in json &&
+      json.references instanceof Array
+    ) {
+      return json.references.map(
+        (r: Record<string, string>) => new Reference(r.path),
+      );
+    } else {
+      return [];
+    }
+  }
+  public format(): string {
+    const compilerOptions = JSON5.parse(this.compilerOptions.format());
+    const json = {
+      compilerOptions,
+      references: this._references.map((r) => ({ path: r.path })),
+      ...this._additionalData,
+    };
+    const ordered = sortKeys(json, compareKeys);
+    return JSON.stringify(ordered, null, 2);
+  }
+  public equals(other: unknown): boolean {
+    if (other instanceof TSConfig) {
+      const sameReferences = haveSameItems(
+        this._references,
+        other._references,
+        (r1, r2) => r1.equals(r2),
+      );
+      return (
+        this._compilerOptions.equals(other._compilerOptions) &&
+        sameReferences &&
+        isEqual(this._additionalData, other._additionalData)
+      );
+    } else {
+      return false;
+    }
+  }
+}
+// TODO: orderKeys (by array);
+function compareKeys(a: string, b: string): number {
+  return getKeyIndex(a) - getKeyIndex(b);
+}
+function getKeyIndex(s: string): number {
+  const order = [
+    'extends',
+    'compilerOptions',
+    'include',
+    'exclude',
+    'references',
+  ];
+  if (order.every((key) => key !== s)) {
+    return Number.MAX_VALUE;
+  } else {
+    return order.indexOf(s);
+  }
+}

package/apps/cli/src/unlink-packages.ts ADDED Viewed

@@ -0,0 +1,47 @@
+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 unlinkPackages(
+  current: Package,
+  target: Package,
+): Promise<void> {
+  await updatePackageJSON(current, target);
+  await updateTSConfig(current, target);
+}
+async function updatePackageJSON(current: Package, target: Package) {
+  const namespace = await getNamespace();
+  const packageJSON = await getDirectoryPackageJson(current.directory);
+  const updated = packageJSON
+    .removeDependency(target.name)
+    .removeDevDependency(target.name);
+  const packageJSONPath = getPackageJSONPath(current.directory);
+  await fs.writeFile(packageJSONPath, updated.format(namespace));
+}
+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 updatedPaths = Object.fromEntries(
+    Object.entries(tsconfig.compilerOptions.paths).filter(
+      ([key]) => key !== target.name,
+    ),
+  );
+  const updatedCompilerOptions =
+    tsconfig.compilerOptions.setPaths(updatedPaths);
+  const updated = tsconfig.setCompilerOptions(updatedCompilerOptions);
+  await fs.writeFile(tsconfigPath, updated.format());
+}

package/apps/cli/src/utils/package-generator.ts ADDED Viewed

@@ -0,0 +1,41 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { FileGenerator, PackageJsonGenerator } from '../file-generator';
+export class PackageGenerator {
+  private readonly _root: string;
+  private readonly _packageJson: PackageJsonGenerator;
+  private readonly _fileGenerators: ReadonlyArray<FileGenerator>;
+  public constructor(
+    root: string,
+    packageJson: PackageJsonGenerator,
+    fileGenerators: ReadonlyArray<FileGenerator> = [],
+  ) {
+    this._root = root;
+    this._packageJson = packageJson;
+    this._fileGenerators = fileGenerators;
+  }
+  public async generate(): Promise<void> {
+    const all = [this._packageJson, ...this._fileGenerators];
+    await fs.mkdir(this._root, { recursive: true });
+    await Promise.all(all.map((gen) => this.write(gen)));
+  }
+  private async write(fileGenerator: FileGenerator): Promise<void> {
+    const contents = await fileGenerator.generate();
+    const filepath = path.join(this._root, fileGenerator.filepath);
+    const directory = path.dirname(filepath);
+    await fs.mkdir(directory, { recursive: true });
+    await fs.writeFile(filepath, contents);
+  }
+}

package/apps/cli/src/utils/package-type.ts ADDED Viewed

@@ -0,0 +1,44 @@
+import { prompt } from 'enquirer';
+export const packageTypes = [
+  'library',
+  'config',
+  'react',
+  'vite',
+  'fastify',
+  'next',
+  'cli',
+] as const;
+export type PackageType = (typeof packageTypes)[number];
+export async function pickPackageType(
+  options?: Record<string, string | undefined>,
+): Promise<PackageType> {
+  if (options?.type && isPackageType(options.type)) {
+    return options.type;
+  } else if (options?.type && !isPackageType(options.type)) {
+    throw new Error(
+      `--type setting "${options.type}" is invalid, must be one of ${packageTypes.join(', ')}.`,
+    );
+  }
+  const response = await prompt<{ type: string }>({
+    type: 'select',
+    name: 'type',
+    message: 'What kind of package do you want?',
+    choices: [...packageTypes],
+  });
+  if (!isPackageType(response.type)) {
+    throw new Error(
+      `Type "${response.type}" is invalid, must be one of ${packageTypes.join(', ')}.`,
+    );
+  }
+  return response.type;
+}
+export function isPackageType(s: string): s is PackageType {
+  return packageTypes.some((p) => p === s);
+}

package/apps/cli/src/utils/package.ts ADDED Viewed

@@ -0,0 +1,126 @@
+import { fileExists, getDirectoryPackageJson } from './utils';
+import { getDirectoryWorkspaceFile, getWorkspaceRoot } from './workspace';
+import { glob } from 'fast-glob';
+import path from 'node:path';
+// TODO: make into class with PackageJSON.
+// TODO: Create Workspace/context...
+export type Package = {
+  name: string;
+  directory: string;
+  type: 'Config' | 'App' | 'Library' | 'Unknown';
+};
+export async function getCurrentPackage(
+  directory: string = process.cwd(),
+): Promise<Package> {
+  const packageRoot = await getPackageRoot(directory);
+  const packageJson = await getDirectoryPackageJson(packageRoot);
+  return getPackageByName(packageJson.name);
+}
+export async function getPackageRoot(
+  directory: string = process.cwd(),
+): Promise<string> {
+  const parent = path.dirname(directory);
+  if (parent === directory) {
+    throw new Error('Not a package.');
+  }
+  if (await isPackageRoot(directory)) {
+    return directory;
+  }
+  return getPackageRoot(parent);
+}
+export async function getPackageByName(name: string): Promise<Package> {
+  const all = await getAllPackages();
+  const match = all.find((p) => p.name === name);
+  if (match === undefined) {
+    throw new Error(`No package with name "${name}".`);
+  }
+  return match;
+}
+export async function getAllPackages(
+  directory: string = process.cwd(),
+): Promise<ReadonlyArray<Package>> {
+  const workspaceRoot = await getWorkspaceRoot(directory);
+  const workspaceFile = (await getDirectoryWorkspaceFile(workspaceRoot)) as {
+    packages: ReadonlyArray<string>;
+  };
+  const results: Array<Package> = [];
+  for (const seg of workspaceFile.packages) {
+    const packageType = getPackageType(seg);
+    const packageJsonPaths = await glob(`${workspaceRoot}/${seg}/package.json`);
+    const packageDirectories = packageJsonPaths.map((p) => path.dirname(p));
+    for (const directory of packageDirectories) {
+      const name = (await getDirectoryPackageJson(directory)).name;
+      results.push({
+        name,
+        directory,
+        type: packageType,
+      });
+    }
+  }
+  return results;
+}
+function getPackageType(segment: string): Package['type'] {
+  if (segment.startsWith('app')) {
+    return 'App';
+  } else if (segment.startsWith('config')) {
+    return 'Config';
+  } else if (segment.startsWith('package') || segment.startsWith('lib')) {
+    return 'Library';
+  } else {
+    return 'Unknown';
+  }
+}
+export function comparePackages(a: Package, b: Package): number {
+  const packageTypeDifference = comparePackageTypes(a.type, b.type);
+  if (packageTypeDifference !== 0) {
+    return packageTypeDifference;
+  } else {
+    return a.name.localeCompare(b.name);
+  }
+}
+function comparePackageTypes(a: Package['type'], b: Package['type']): number {
+  return getPackageTypeIndex(a) - getPackageTypeIndex(b);
+}
+function getPackageTypeIndex(packageType: Package['type']): number {
+  switch (packageType) {
+    case 'Library':
+      return 0;
+    case 'Config':
+      return 1;
+    case 'App':
+      return 2;
+    case 'Unknown':
+      return 3;
+  }
+}
+async function isPackageRoot(directory: string): Promise<boolean> {
+  return await fileExists(path.join(directory, 'package.json'));
+}

package/apps/cli/src/utils/style-type.ts ADDED Viewed

@@ -0,0 +1,41 @@
+import { prompt } from 'enquirer';
+export const styleTypes = [
+  'tailwind',
+  'css-modules',
+  'styled-components',
+  'none',
+] as const;
+export type StyleType = (typeof styleTypes)[number];
+export async function pickStyleType(
+  options?: Record<string, string | undefined>,
+): Promise<StyleType> {
+  if (options?.style && isStyleType(options?.style)) {
+    return options?.style;
+  } else if (options?.style && !isStyleType(options?.style)) {
+    throw new Error(
+      `--style setting "${options.style}" is invalid, must be one of ${styleTypes.join(', ')}.`,
+    );
+  }
+  const response = await prompt<{ type: string }>({
+    type: 'select',
+    name: 'type',
+    message: 'What kind of style do you want?',
+    choices: [...styleTypes],
+  });
+  if (!isStyleType(response.type)) {
+    throw new Error(
+      `Type "${response.type}" is invalid, must be one of ${styleTypes.join(', ')}.`,
+    );
+  }
+  return response.type;
+}
+export function isStyleType(s: string): s is StyleType {
+  return styleTypes.some((p) => p === s);
+}