ts-ag 0.0.1-dev.3 → 1.0.1

package/src/scripts/clean.ts

@@ -1,75 +1,41 @@
 #!/usr/bin/env node
 
-import * as fs from 'fs';
-import * as path from 'path';
-
-interface Args {
-  dirExcludes: string[];
-  dirIncludes: string[];
-}
-
-function parseArgs(): Args {
-  const args = process.argv.slice(2);
-  const dirExcludes: string[] = [];
-  const dirIncludes: string[] = [];
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] === '--dir-excludes' && args[i + 1]) {
-      dirExcludes.push(args[i + 1]);
-      i++;
-    } else if (args[i] === '--dir-includes' && args[i + 1]) {
-      dirIncludes.push(args[i + 1]);
-      i++;
-    }
-  }
-  return { dirExcludes, dirIncludes };
-}
-
-function shouldExclude(dir: string, excludes: string[]): boolean {
-  return excludes.some((ex) => path.basename(dir) === ex);
-}
-
-function shouldInclude(dir: string, includes: string[]): boolean {
-  if (includes.length === 0) return true;
-  return includes.some((inc) => dir.includes(inc));
-}
-
-function removeDir(targetPath: string) {
-  if (fs.existsSync(targetPath)) {
-    fs.rmSync(targetPath, { recursive: true, force: true });
-    console.log(`Removed: ${targetPath}`);
-  }
-}
-
-function clean(root: string, args: Args) {
-  const entries = fs.readdirSync(root, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = path.join(root, entry.name);
-    if (entry.isDirectory()) {
-      if (entry.name === 'node_modules') continue;
-      if (entry.name === 'dist') {
-        const distParentDir = path.dirname(fullPath);
-        const siblingDirs = fs
-          .readdirSync(distParentDir, { withFileTypes: true })
-          .filter((d) => d.isDirectory())
-          .map((d) => d.name);
-
-        const shouldExcludeSibling = args.dirExcludes.some((ex) => siblingDirs.includes(ex));
-        const shouldIncludeSibling =
-          args.dirIncludes.length === 0 || args.dirIncludes.some((inc) => siblingDirs.includes(inc));
-
-        if (!shouldExcludeSibling && shouldIncludeSibling) {
-          removeDir(fullPath);
-        }
-        continue;
+import { readFileSync, rmSync } from 'fs';
+import { resolve, dirname, join } from 'path';
+import { parse } from 'tsconfck';
+
+async function listReferences(tsconfigPath: string, visited = new Set<string>()) {
+  // console.log(`Processing: ${tsconfigPath}`);
+  tsconfigPath = resolve(tsconfigPath);
+  if (visited.has(tsconfigPath)) return;
+  visited.add(tsconfigPath);
+
+  const { tsconfig } = await parse(tsconfigPath);
+  const dir = dirname(tsconfigPath);
+
+  // console.log(`Found tsconfig: ${tsconfigPath}`, tsconfig);
+
+  if (tsconfig.references && Array.isArray(tsconfig.references)) {
+    for (const ref of tsconfig.references) {
+      if (typeof ref.path === 'string') {
+        const dirPath = ref.path.split('/').slice(0, -1).join('/');
+        const configFilename = ref.path.endsWith('.json') ? ref.path.split('/').pop() : 'tsconfig.json';
+        await listReferences(resolve(dir, dirPath, configFilename), visited);
       }
-      if (!shouldExclude(fullPath, args.dirExcludes)) {
-        clean(fullPath, args);
-      }
-    } else if (entry.name === 'tsconfig.tsbuildinfo') {
-      removeDir(fullPath);
     }
   }
 }
 
-const args = parseArgs();
-clean(process.cwd(), args);
+const configs = new Set<string>();
+await listReferences(process.argv[2] || 'tsconfig.json', configs);
+console.log('Referenced tsconfig files:');
+for (const conf of configs) {
+  const dir = dirname(conf);
+  const configName = conf.split('/').pop()?.slice(0, -5) || 'tsconfig';
+
+  rmSync(join(dir, 'dist'), { recursive: true, force: true });
+  rmSync(join(dir, configName + '.tsbuildinfo'), { recursive: true, force: true });
+  console.log('Removed dist and tsbuildinfo for:', conf);
+  // console.log('  Dist: ', join(dir, 'dist'));
+  // console.log('  tsbuildinfo: ', join(dir, configName + '.tsbuildinfo'));
+}

package/src/ses/errors.ts

@@ -0,0 +1,3 @@
+export const error_ses = {
+  type: 'ses' as const
+};

package/src/ses/index.ts

@@ -0,0 +1 @@
+export * from './errors.js';

package/src/types/deep.ts

@@ -0,0 +1,43 @@
+/**
+ * @example
+ * type HomeOverridden = DeepOverride<Home, {
+ *   test: {
+ *     featuredImages: never; // Removing the property
+ *     meta: {
+ *       updatedAt: string; // Changing the type
+ *     };
+ *   };
+ * }>;
+ */
+export type DeepOverride<T, R> = {
+  [K in keyof T]: K extends keyof R
+    ? R[K] extends infer RK // Get override type
+      ? RK extends Record<string, any> // If override is an object
+        ? T[K] extends Record<string, any> // If original is an object
+          ? DeepOverride<T[K], RK> // Recursively override
+          : RK // Replace value
+        : RK extends Array<infer RU> // If override is an array
+          ? T[K] extends Array<infer TU> // If original is also an array
+            ? Array<DeepOverride<TU, RU>> // Recursively apply to array items
+            : RK // Direct replacement
+          : RK // Direct replacement
+      : never
+    : T[K]; // Keep original type if not overridden
+};
+
+/**
+ *
+ */
+export type DeepPartial<T> = {
+  [P in keyof T]?: T[P] extends object
+    ? // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+      T[P] extends Function
+      ? T[P]
+      : DeepPartial<T[P]>
+    : T[P];
+};
+
+export type DeepRequired<T> = {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+  [P in keyof T]-?: NonNullable<T[P] extends object ? (T[P] extends Function ? T[P] : DeepRequired<T[P]>) : T[P]>;
+};

package/src/types/index.ts

@@ -0,0 +1,2 @@
+export * from './deep.js';
+export * from './safe.js';

package/src/types/safe.ts

@@ -0,0 +1 @@
+export type SafeOmit<T, K extends keyof any> = T extends any ? Omit<T, K> : never;

package/src/utils/fs.ts

@@ -1,6 +1,7 @@
 import { lstat, mkdir, readFile, writeFile } from 'fs/promises';
 import { dirname } from 'path';
 import chalk from 'chalk';
+import type { PackageJson } from 'type-fest';
 
 /**
  * @returns true if a filepath exists
@@ -16,8 +17,9 @@ export async function exists(filePath: string): Promise<boolean> {
 
 /**
  * Writes data to a filepath if it is different
+ * @returns true if the file is written to
  */
-export async function writeIfDifferent(filePath: string, newData: string) {
+export async function writeIfDifferent(filePath: string, newData: string): Promise<boolean> {
   // Ensure the directory exists
   const directory = dirname(filePath);
   if (!(await exists(directory))) {
@@ -32,11 +34,20 @@ export async function writeIfDifferent(filePath: string, newData: string) {
     // Compare the existing data with the new data
     if (existingData === newData) {
       // console.log('File contents are identical. No write needed.');
-      return;
+      return false;
     }
   }
 
   // Write the new data if it's different or the file doesn't exist
   await writeFile(filePath, newData, 'utf8');
   console.log(chalk.green('Writing to'), filePath);
+  return true;
+}
+
+/**
+ * @returns the json object packageJson or undefined if it doesnt exist
+ */
+export async function readPackageJson(filePath: string): Promise<PackageJson | undefined> {
+  if (!(await exists(filePath))) return undefined;
+  return JSON.parse(await readFile(filePath, { encoding: 'utf-8' })) as PackageJson;
 }