GeezerVison is showing github.com — aicodingstack.io/scripts/refactor/sort-locales-fields.ts at main · aicodingstack/aicodingstack.io

Expand file tree

sort-locales-fields.ts

Copy path

More file actions

Latest commit

History

121 lines (96 loc) · 3.31 KB

sort-locales-fields.ts

Copy path

File metadata and controls

121 lines (96 loc) · 3.31 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

#!/usr/bin/env node

/**

* Sort fields in all translation JSON files alphabetically

* This script recursively processes all JSON files in the translations directory

* and sorts their object keys alphabetically (including nested objects).

import fs from 'node:fs/promises'

import path from 'node:path'

import { fileURLToPath } from 'node:url'

const __filename = fileURLToPath(import.meta.url)

const __dirname = path.dirname(__filename)

const ROOT_DIR = path.resolve(__dirname, '../..')

const LOCALES_DIR = path.join(ROOT_DIR, 'translations')

interface JsonFile {

fullPath: string

relativePath: string

}

/**

* Recursively sort object keys alphabetically

* Arrays are preserved as-is, only object keys are sorted

function sortObjectKeysRecursively(obj: unknown): unknown {

if (Array.isArray(obj)) {

return obj.map(item => sortObjectKeysRecursively(item))

}

if (obj && typeof obj === 'object') {

const sorted: Record<string, unknown> = {}

const keys = Object.keys(obj).sort()

for (const key of keys) {

sorted[key] = sortObjectKeysRecursively((obj as Record<string, unknown>)[key])

}

return sorted

}

return obj

}

/**

* Process a single JSON file

async function processJsonFile(filePath: string, relativePath: string): Promise<void> {

try {

// Read the file

const content = await fs.readFile(filePath, 'utf-8')

const data = JSON.parse(content)

// Sort the data recursively

const sortedData = sortObjectKeysRecursively(data)

// Write back to file with 2-space indentation

const jsonContent = `${JSON.stringify(sortedData, null, 2)}\n`

await fs.writeFile(filePath, jsonContent, 'utf-8')

console.log(` ✅ ${relativePath}`)

} catch (error) {

console.error(` ❌ Error processing ${relativePath}:`, (error as Error).message)

}

/**

* Recursively find all JSON files in a directory

async function findJsonFiles(dirPath: string, basePath = dirPath): Promise<JsonFile[]> {

const jsonFiles: JsonFile[] = []

try {

const entries = await fs.readdir(dirPath, { withFileTypes: true })

for (const entry of entries) {

const fullPath = path.join(dirPath, entry.name)

if (entry.isDirectory()) {

// Recursively search subdirectories

const subFiles = await findJsonFiles(fullPath, basePath)

jsonFiles.push(...subFiles)

} else if (entry.isFile() && entry.name.endsWith('.json')) {

// Calculate relative path from base

const relativePath = path.relative(basePath, fullPath)

jsonFiles.push({ fullPath, relativePath })

}

} catch (error) {

console.error(` ⚠️ Error reading directory ${dirPath}:`, (error as Error).message)

}

return jsonFiles

}

/**

* Main function

async function main(): Promise<void> {

console.log('🔄 Sorting translations JSON files alphabetically...\n')

// Find all JSON files in translations directory

const jsonFiles = await findJsonFiles(LOCALES_DIR)

if (jsonFiles.length === 0) {

console.log('⚠️ No JSON files found in translations directory')

return

}

console.log(`📁 Found ${jsonFiles.length} JSON file(s) to process\n`)

// Process each file

for (const { fullPath, relativePath } of jsonFiles) {

await processJsonFile(fullPath, relativePath)

}

console.log('\n✨ Done!')

}

main().catch(console.error)