sandstone 1.0.0-beta.3 → 1.0.0-beta.5

package/patches/@stylistic%2Feslint-plugin@5.7.1.patch

@@ -1,13 +0,0 @@
-diff --git a/dist/rules/list-style.js b/dist/rules/list-style.js
-index 078a3a73240a5876d38c6797ada0b367b3c5dbe1..f7b69ad67f999ad6f2a400012e8200020d22a6fb 100644
---- a/dist/rules/list-style.js
-+++ b/dist/rules/list-style.js
-@@ -83,7 +83,7 @@ var list_style_default = createRule({
- 		defaultOptions: [{
- 			singleLine: {
- 				spacing: "never",
--				maxItems: Number.POSITIVE_INFINITY
-+				maxItems: 9007199254740991
- 			},
- 			multiLine: { minItems: 0 },
- 			overrides: { "{}": { singleLine: { spacing: "always" } } }

package/scripts/build.ts

@@ -1,205 +0,0 @@
-/**
- * Build script for sandstone
- * Uses Bun.build for JS bundling and tsc for type declarations
- *
- * Note: We build each entry point separately without code splitting to avoid
- * issues with Bun's lazy initialization (__esm) which breaks class inheritance.
- */
-
-import { join } from 'path'
-import { rm, mkdir, readdir, readFile, writeFile, stat } from 'fs/promises'
-import { createHasInstancePlugin } from './plugins/hasinstance-plugin'
-import { fixDtsImports } from './plugins/fix-dts-imports'
-
-const rootDir = join(import.meta.dir, '..')
-const srcDir = join(rootDir, 'src')
-const distDir = join(rootDir, 'dist')
-
-// Check for silent flag
-const silent = process.argv.includes('--silent') || process.argv.includes('-s')
-const log = (...args: unknown[]) => { if (!silent) console.log(...args) }
-
-/**
- * Get external packages from package.json dependencies.
- * These are npm dependencies that should NOT be bundled.
- * Note: sandstone/* path aliases should be bundled, not treated as external.
- */
-async function getExternalPackages(): Promise<string[]> {
-  const packageJson = JSON.parse(await readFile(join(rootDir, 'package.json'), 'utf8'))
-  return Object.keys(packageJson.dependencies || {})
-}
-
-// Subpath entry points (each built separately)
-const subEntries = [
-  'src/arguments/index.ts',
-  'src/commands/index.ts',
-  'src/core/index.ts',
-  'src/flow/index.ts',
-  'src/pack/index.ts',
-  'src/variables/index.ts',
-]
-
-async function main() {
-  const startTime = performance.now()
-
-  log('Building sandstone...\n')
-
-  // Clean dist directory
-  await rm(distDir, { recursive: true, force: true })
-  await mkdir(distDir, { recursive: true })
-
-  // Create the hasinstance plugin to inject Symbol.hasInstance patterns
-  log('Analyzing instanceof usage...')
-  const hasInstancePlugin = await createHasInstancePlugin(srcDir, silent)
-
-  // Get external packages from package.json
-  const externalPackages = await getExternalPackages()
-
-  // Build each subpath entry point separately
-  // Building separately avoids Bun crashes and ensures each bundle is self-contained
-  log('Building JavaScript bundles...')
-
-  for (const entry of subEntries) {
-    const entryPath = join(rootDir, entry)
-    const entryName = entry.replace('src/', '').replace('/index.ts', '')
-
-    log(`  Building ${entryName}...`)
-
-    const result = await Bun.build({
-      entrypoints: [entryPath],
-      outdir: join(distDir, entryName),
-      target: 'node',
-      format: 'esm',
-      splitting: false,
-      external: externalPackages,
-      naming: 'index.js',
-      plugins: [hasInstancePlugin],
-    })
-
-    if (!result.success) {
-      console.error(`Build failed for ${entryName}:`)
-      for (const log of result.logs) {
-        console.error(log)
-      }
-      process.exit(1)
-    }
-  }
-
-  // Build main index
-  log('  Building main index...')
-  const mainResult = await Bun.build({
-    entrypoints: [join(srcDir, 'index.ts')],
-    outdir: distDir,
-    target: 'node',
-    format: 'esm',
-    splitting: false,
-    external: externalPackages,
-    naming: 'index.js',
-    plugins: [hasInstancePlugin],
-  })
-
-  if (!mainResult.success) {
-    console.error('Main index build failed:')
-    for (const log of mainResult.logs) {
-      console.error(log)
-    }
-    process.exit(1)
-  }
-
-  log('  Done building JS bundles')
-
-  // Generate declarations with tsc
-  log('Generating type declarations...')
-  const tsc = Bun.spawn(['bun', 'tsc', '-p', 'tsconfig.build.json'], {
-    cwd: rootDir,
-    stdout: 'inherit',
-    stderr: 'inherit',
-  })
-  await tsc.exited
-
-  // Fix .d.ts imports (convert path aliases and add .js extensions)
-  log('Fixing declaration imports...')
-  await fixDtsImportsInDir(distDir)
-
-  const elapsed = ((performance.now() - startTime) / 1000).toFixed(2)
-  log(`\nBuild completed in ${elapsed}s`)
-}
-
-async function* walkDir(dir: string, ext: string): AsyncGenerator<string> {
-  const entries = await readdir(dir, { withFileTypes: true })
-  for (const entry of entries) {
-    const path = join(dir, entry.name)
-    if (entry.isDirectory()) {
-      yield* walkDir(path, ext)
-    } else if (entry.name.endsWith(ext)) {
-      yield path
-    }
-  }
-}
-
-/**
- * Recursively find all directories that contain an index.ts file
- * These directories need /index.js appended when imported
- */
-async function findIndexDirs(dir: string, relativeTo: string = dir): Promise<Set<string>> {
-  const indexDirs = new Set<string>()
-  const entries = await readdir(dir, { withFileTypes: true })
-
-  for (const entry of entries) {
-    if (entry.isDirectory()) {
-      const fullPath = join(dir, entry.name)
-      const indexPath = join(fullPath, 'index.ts')
-
-      // Check if this directory has an index.ts
-      try {
-        await stat(indexPath)
-        // Store the relative path from src (e.g., "arguments", "arguments/resources")
-        const relativePath = fullPath.replace(relativeTo, '').replace(/\\/g, '/').replace(/^\//, '')
-        indexDirs.add(relativePath)
-      } catch {
-        // No index.ts in this directory
-      }
-
-      // Recurse into subdirectories
-      const subDirs = await findIndexDirs(fullPath, relativeTo)
-      for (const subDir of subDirs) {
-        indexDirs.add(subDir)
-      }
-    }
-  }
-
-  return indexDirs
-}
-
-// Cache for index directories (populated at build time)
-let indexDirsCache: Set<string> | null = null
-
-async function getIndexDirs(): Promise<Set<string>> {
-  if (!indexDirsCache) {
-    indexDirsCache = await findIndexDirs(srcDir)
-  }
-  return indexDirsCache
-}
-
-async function fixDtsImportsInDir(distDir: string): Promise<void> {
-  let fixedCount = 0
-  const indexDirs = await getIndexDirs()
-
-  for await (const filePath of walkDir(distDir, '.d.ts')) {
-    const content = await readFile(filePath, 'utf8')
-    const fileDir = join(filePath, '..')
-    const result = fixDtsImports(content, fileDir, distDir, indexDirs)
-
-    if (result.modified) {
-      await writeFile(filePath, result.content)
-      fixedCount++
-    }
-  }
-
-  log(`  Fixed imports in ${fixedCount} declaration files`)
-}
-
-main().catch((err) => {
-  console.error('Build error:', err)
-  process.exit(1)
-})

package/scripts/plugins/find-instanceof-classes.ts

@@ -1,114 +0,0 @@
-/**
- * Scans the codebase to find classes that are checked with instanceof,
- * and locates where those classes are defined.
- */
-
-import ts from 'typescript'
-import { Glob } from 'bun'
-
-export interface InstanceofInfo {
-  className: string
-  usedInFiles: string[]
-}
-
-/**
- * Normalizes a file path to use forward slashes.
- */
-function normalizePath(path: string): string {
-  return path.replace(/\\/g, '/')
-}
-
-/**
- * Scans all TypeScript files in the source directory to find
- * `instanceof ClassName` expressions and collects the class names.
- */
-export async function findInstanceofClasses(srcDir: string): Promise<Map<string, InstanceofInfo>> {
-  const instanceofClasses = new Map<string, InstanceofInfo>()
-  const glob = new Glob('**/*.ts')
-
-  for await (const rawFilePath of glob.scan(srcDir)) {
-    const filePath = normalizePath(rawFilePath)
-    const fullPath = `${srcDir}/${filePath}`
-    const source = await Bun.file(fullPath).text()
-    const sourceFile = ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true)
-
-    const visit = (node: ts.Node) => {
-      // Match: expr instanceof ClassName
-      if (
-        ts.isBinaryExpression(node) &&
-        node.operatorToken.kind === ts.SyntaxKind.InstanceOfKeyword &&
-        ts.isIdentifier(node.right)
-      ) {
-        const className = node.right.text
-        const existing = instanceofClasses.get(className)
-        if (existing) {
-          if (!existing.usedInFiles.includes(filePath)) {
-            existing.usedInFiles.push(filePath)
-          }
-        } else {
-          instanceofClasses.set(className, { className, usedInFiles: [filePath] })
-        }
-      }
-      ts.forEachChild(node, visit)
-    }
-
-    ts.forEachChild(sourceFile, visit)
-  }
-
-  return instanceofClasses
-}
-
-/**
- * Scans the source directory to find where each of the given classes is defined.
- * Returns a Map of className -> relative file path (normalized with forward slashes).
- */
-export async function findClassDefinitions(
-  srcDir: string,
-  classNames: Set<string>,
-): Promise<Map<string, string>> {
-  const classLocations = new Map<string, string>()
-  const glob = new Glob('**/*.ts')
-
-  for await (const rawFilePath of glob.scan(srcDir)) {
-    const filePath = normalizePath(rawFilePath)
-    const fullPath = `${srcDir}/${filePath}`
-    const source = await Bun.file(fullPath).text()
-    const sourceFile = ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true)
-
-    const visit = (node: ts.Node) => {
-      if (ts.isClassDeclaration(node) && node.name && classNames.has(node.name.text)) {
-        classLocations.set(node.name.text, filePath)
-      }
-      ts.forEachChild(node, visit)
-    }
-
-    ts.forEachChild(sourceFile, visit)
-  }
-
-  return classLocations
-}
-
-/**
- * Convenience function that combines findInstanceofClasses and findClassDefinitions
- * to build a map of files to the classes they contain that need Symbol.hasInstance.
- */
-export async function buildFileToClassesMap(
-  srcDir: string,
-): Promise<{ fileToClasses: Map<string, string[]>; classNames: Set<string> }> {
-  // Find all instanceof checks
-  const instanceofClasses = await findInstanceofClasses(srcDir)
-  const classNames = new Set(instanceofClasses.keys())
-
-  // Find where each class is defined
-  const classLocations = await findClassDefinitions(srcDir, classNames)
-
-  // Build map of file -> classes to transform
-  const fileToClasses = new Map<string, string[]>()
-  for (const [className, filePath] of classLocations) {
-    const existing = fileToClasses.get(filePath) || []
-    existing.push(className)
-    fileToClasses.set(filePath, existing)
-  }
-
-  return { fileToClasses, classNames }
-}

package/scripts/plugins/fix-dts-imports.ts

@@ -1,185 +0,0 @@
-/**
- * Fixes import paths in TypeScript declaration files using AST manipulation.
- * - Converts path aliases (sandstone/*) to relative paths
- * - Adds .js extensions to relative imports
- * - Handles directory imports with /index.js
- */
-
-import ts from 'typescript'
-import { join } from 'path'
-
-/**
- * Fixes import paths in a .d.ts file.
- *
- * @param source - The source code of the .d.ts file
- * @param fileDir - The directory containing this file (absolute path)
- * @param distDir - The root dist directory (absolute path)
- * @param indexDirs - Set of relative paths (from distDir) that have index.ts files
- */
-export function fixDtsImports(
-  source: string,
-  fileDir: string,
-  distDir: string,
-  indexDirs: Set<string>,
-): { content: string; modified: boolean } {
-  const sourceFile = ts.createSourceFile('file.d.ts', source, ts.ScriptTarget.Latest, true)
-
-  let modified = false
-
-  // Calculate the relative path prefix based on file depth
-  const relativeToSrc = fileDir.replace(distDir, '').replace(/\\/g, '/')
-  const depth = relativeToSrc.split('/').filter(Boolean).length
-  const relPrefix = depth > 0 ? '../'.repeat(depth) : './'
-
-  /**
-   * Resolves an import path, converting sandstone/* to relative and adding extensions.
-   */
-  function resolveModulePath(importPath: string): string | undefined {
-    // Handle sandstone/* path aliases
-    if (importPath.startsWith('sandstone/')) {
-      const subPath = importPath.slice('sandstone/'.length).replace(/\.ts$/, '')
-      if (indexDirs.has(subPath)) {
-        return `${relPrefix}${subPath}/index.js`
-      }
-      return `${relPrefix}${subPath}.js`
-    }
-
-    // Handle sandstone root import
-    if (importPath === 'sandstone') {
-      return `${relPrefix}index.js`
-    }
-
-    // Handle relative imports
-    if (importPath.startsWith('./') || importPath.startsWith('../')) {
-      // Skip if already has extension
-      if (importPath.endsWith('.js') || importPath.endsWith('.json')) {
-        return undefined
-      }
-
-      // Remove .ts extension if present
-      const cleanPath = importPath.replace(/\.ts$/, '')
-
-      // Check if this resolves to a directory with an index file
-      if (isIndexDir(cleanPath, fileDir, distDir, indexDirs)) {
-        return `${cleanPath}/index.js`
-      }
-
-      return `${cleanPath}.js`
-    }
-
-    return undefined
-  }
-
-  /**
-   * Updates a module specifier string literal if needed.
-   */
-  function maybeUpdateModuleSpecifier(specifier: ts.StringLiteral): ts.StringLiteral | undefined {
-    const newPath = resolveModulePath(specifier.text)
-    if (newPath && newPath !== specifier.text) {
-      modified = true
-      return ts.factory.createStringLiteral(newPath)
-    }
-    return undefined
-  }
-
-  const transformer: ts.TransformerFactory<ts.SourceFile> = (context) => {
-    return (root) => {
-      const visit: ts.Visitor = (node): ts.Node => {
-        // Handle: import { X } from 'path'
-        if (ts.isImportDeclaration(node) && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
-          const newSpecifier = maybeUpdateModuleSpecifier(node.moduleSpecifier)
-          if (newSpecifier) {
-            return ts.factory.updateImportDeclaration(
-              node,
-              node.modifiers,
-              node.importClause,
-              newSpecifier,
-              node.attributes,
-            )
-          }
-        }
-
-        // Handle: export { X } from 'path'
-        if (ts.isExportDeclaration(node) && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
-          const newSpecifier = maybeUpdateModuleSpecifier(node.moduleSpecifier)
-          if (newSpecifier) {
-            return ts.factory.updateExportDeclaration(
-              node,
-              node.modifiers,
-              node.isTypeOnly,
-              node.exportClause,
-              newSpecifier,
-              node.attributes,
-            )
-          }
-        }
-
-        // Handle: import("path") type imports
-        if (ts.isImportTypeNode(node) && ts.isLiteralTypeNode(node.argument)) {
-          const literal = node.argument.literal
-          if (ts.isStringLiteral(literal)) {
-            const newPath = resolveModulePath(literal.text)
-            if (newPath && newPath !== literal.text) {
-              modified = true
-              return ts.factory.updateImportTypeNode(
-                node,
-                ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(newPath)),
-                node.attributes,
-                node.qualifier,
-                node.typeArguments,
-                node.isTypeOf,
-              )
-            }
-          }
-        }
-
-        return ts.visitEachChild(node, visit, context)
-      }
-
-      return ts.visitNode(root, visit) as ts.SourceFile
-    }
-  }
-
-  const result = ts.transform(sourceFile, [transformer])
-  const transformedFile = result.transformed[0]
-
-  if (!modified) {
-    result.dispose()
-    return { content: source, modified: false }
-  }
-
-  const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed })
-  const output = printer.printFile(transformedFile)
-
-  result.dispose()
-  return { content: output, modified: true }
-}
-
-/**
- * Checks if a relative import path resolves to a directory with an index file.
- */
-function isIndexDir(
-  importPath: string,
-  fromFileDir: string,
-  distDir: string,
-  indexDirs: Set<string>,
-): boolean {
-  // Get the relative path of the file's directory from distDir
-  const fromRelative = fromFileDir.replace(distDir, '').replace(/\\/g, '/').replace(/^\//, '')
-  const fromParts = fromRelative.split('/').filter(Boolean)
-
-  // Parse the import path and resolve it relative to the file
-  const importParts = importPath.split('/')
-  const currentParts = [...fromParts]
-
-  for (const part of importParts) {
-    if (part === '..') {
-      currentParts.pop()
-    } else if (part !== '.') {
-      currentParts.push(part)
-    }
-  }
-
-  const resolvedPath = currentParts.join('/')
-  return indexDirs.has(resolvedPath)
-}