@brickflow/cli 0.0.6 → 0.0.8

package/src/translate/utils.js

@@ -0,0 +1,409 @@
+import { parse as babelParse } from '@babel/parser'
+import traverseModule from '@babel/traverse'
+import bkt from '@babel/types'
+const { isIdentifier, isMemberExpression, isStringLiteral, isTemplateLiteral } = bkt
+import { compileTemplate, parse as parseSFC } from '@vue/compiler-sfc'
+import { execFileSync } from 'child_process'
+import { createHash } from 'crypto'
+import { existsSync } from 'fs'
+import { globSync } from 'glob'
+import { join, resolve } from 'path'
+
+const tTraverse = traverseModule.default || traverseModule
+const IGNORED_GLOB_PATTERNS = [
+  '**/node_modules/**',
+  '**/.nuxt/**',
+  '**/dist/**',
+  '**/.output/**',
+  '**/coverage/**',
+  '**/public/**',
+]
+const IGNORED_SOURCE_SEGMENTS = ['/node_modules/', '/.nuxt/', '/dist/', '/.output/', '/coverage/', '/public/']
+const TRANSLATION_SAMPLE_GLOB =
+  '{packages/brick,apps/*}/{components/**/translate,pages-translate/*,layouts/**,global/*}/sample.json'
+
+export function compileVueToJS(code, filePath) {
+  const { descriptor } = parseSFC(code)
+
+  let result = ''
+
+  if (descriptor.script?.content) {
+    result += `${descriptor.script.content}\n`
+  }
+
+  if (descriptor.scriptSetup?.content) {
+    result += `${descriptor.scriptSetup.content}\n`
+  }
+
+  if (descriptor.template?.content) {
+    const compiled = compileTemplate({
+      filename: filePath,
+      id: filePath,
+      source: descriptor.template.content,
+    })
+
+    result += compiled.code
+  }
+
+  return result
+}
+
+export function extractStrings(code, id) {
+  const ast = babelParse(code, {
+    plugins: getBabelPlugins(id),
+    sourceType: 'module',
+  })
+
+  const result = new Map()
+  const component = getComponentName(id)
+
+  tTraverse(ast, {
+    CallExpression(pathAst) {
+      if (!isTCall(pathAst.node)) {
+        return
+      }
+
+      const arg = pathAst.node.arguments[0]
+      const text = getStaticText(arg)
+
+      if (text === null) {
+        return
+      }
+
+      const key = generateKey(text, component)
+
+      result.set(key, text)
+    },
+  })
+
+  return result
+}
+
+export function generateKey(text, component) {
+  const normalized = normalize(text)
+  const cased = toSnake(normalized).slice(0, 10)
+  const hash = shortHash(normalized)
+
+  return `${component}.${cased}_${hash}`
+}
+
+export function getComponentName(id) {
+  const normalizedId = id.replace(/[?#].*$/, '')
+
+  if (/\/pages\//.test(normalizedId)) {
+    const pagePath = normalizedId.split('/pages/')[1].replace(/\.\w+$/, '')
+
+    return pagePath
+      .split('/')
+      .filter(Boolean)
+      .map((segment) => toPageSegmentName(segment))
+      .join('_')
+  }
+
+  if (/\/layouts\//.test(normalizedId)) {
+    const layoutPath = normalizedId
+      .split('/layouts/')[1]
+      .replace(/\.\w+$/, '')
+      .replace(/\/index$/, '')
+    const segments = [getProjectName(normalizedId), 'layouts', ...layoutPath.split('/').filter(Boolean)]
+
+    return segments.map((segment) => toPascal(segment)).join('')
+  }
+
+  if (!normalizedId.endsWith('.vue')) {
+    return getScriptName(normalizedId)
+  }
+
+  const parts = normalizedId.split('/')
+  parts.pop()
+
+  const dirs = parts.slice(-2)
+
+  return dirs.map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join('')
+}
+
+export function getProjectName(id) {
+  return getProjectRoot(id)?.split('/').pop() ?? 'project'
+}
+
+export function getProjectRoot(id) {
+  const normalizedId = id.replace(/[?#].*$/, '')
+  const brickMatch = normalizedId.match(/^(.*\/packages\/brick)(?:\/|$)/)
+
+  if (brickMatch) {
+    return brickMatch[1]
+  }
+
+  const appMatch = normalizedId.match(/^(.*\/apps\/[^/]+)(?:\/|$)/)
+
+  return appMatch?.[1] ?? null
+}
+
+export function getScriptName(id) {
+  const relativePath = id.split('/packages/')[1] ?? id.split('/apps/')[1] ?? id.replace(/^\//, '')
+
+  return toPageName(relativePath.replace(/\.\w+$/, '').replace(/\//g, '_'))
+}
+
+export function getTranslationPaths(id) {
+  if (isVueSubResourceId(id)) {
+    return null
+  }
+
+  const normalizedId = id.replace(/[?#].*$/, '')
+  if (isIgnoredSourcePath(normalizedId)) {
+    return null
+  }
+
+  if (normalizedId.endsWith('/book.vue')) {
+    return null
+  }
+
+  const isComponent =
+    normalizedId.endsWith('.vue') &&
+    (normalizedId.includes('/packages/brick/components/') ||
+      (normalizedId.includes('/apps/') && normalizedId.includes('/components/')))
+  const isPage = normalizedId.endsWith('.vue') && normalizedId.includes('/pages/')
+  const isLayout = normalizedId.endsWith('.vue') && normalizedId.includes('/layouts/')
+  const projectRoot = getProjectRoot(normalizedId)
+  const isScript =
+    !normalizedId.endsWith('.vue') &&
+    Boolean(projectRoot) &&
+    /\.(?:js|ts)$/.test(normalizedId) &&
+    !normalizedId.endsWith('.d.ts')
+
+  if (!isComponent && !isPage && !isLayout && !isScript) {
+    return null
+  }
+
+  if (isComponent) {
+    const componentDir = normalizedId.split('/').slice(0, -1).join('/')
+    const baseDir = join(componentDir, 'translate')
+
+    return {
+      baseDir,
+      isComponent,
+      isPage,
+      isScript,
+      samplePath: join(baseDir, 'sample.json'),
+    }
+  }
+
+  if (isPage) {
+    const pagesRoot = `${normalizedId.split('/pages/')[0]}/pages`
+    const rootDir = join(pagesRoot, '..', 'pages-translate')
+    const name = getComponentName(normalizedId)
+    const baseDir = join(rootDir, name)
+
+    return {
+      baseDir,
+      isComponent,
+      isPage,
+      isScript,
+      samplePath: join(baseDir, 'sample.json'),
+    }
+  }
+
+  if (isLayout) {
+    const layoutDir = normalizedId.split('/').slice(0, -1).join('/')
+    const fileName =
+      normalizedId
+        .split('/')
+        .pop()
+        ?.replace(/\.\w+$/, '') ?? ''
+    const baseDir = join(layoutDir, fileName)
+
+    return {
+      baseDir,
+      isComponent,
+      isLayout,
+      isPage,
+      isScript,
+      samplePath: join(baseDir, 'sample.json'),
+    }
+  }
+
+  const baseDir = join(projectRoot, 'global', getComponentName(normalizedId))
+
+  return {
+    baseDir,
+    isComponent,
+    isLayout,
+    isPage,
+    isScript,
+    samplePath: join(baseDir, 'sample.json'),
+  }
+}
+
+export function listWorkspaceFiles(workspaceRoot) {
+  try {
+    const output = execFileSync('git', ['ls-files', '-co', '--exclude-standard', '-z'], {
+      cwd: workspaceRoot,
+      encoding: 'utf-8',
+    })
+
+    return output
+      .split('\0')
+      .filter(Boolean)
+      .map((file) => resolve(workspaceRoot, file))
+      .filter((filePath) => existsSync(filePath))
+  } catch {
+    return globSync('**/*', {
+      absolute: true,
+      cwd: workspaceRoot,
+      ignore: IGNORED_GLOB_PATTERNS,
+      nodir: true,
+    })
+  }
+}
+
+export function listTranslationSamplePaths(workspaceRoot) {
+  return globSync(TRANSLATION_SAMPLE_GLOB, {
+    absolute: true,
+    cwd: workspaceRoot,
+    ignore: IGNORED_GLOB_PATTERNS,
+  }).sort()
+}
+
+export function listTranslationTargets(workspaceRoot) {
+  const samplePaths = listTranslationSamplePaths(workspaceRoot)
+  const sourceFiles = listWorkspaceFiles(workspaceRoot).filter(
+    (filePath) => /\.(?:js|ts|vue)$/.test(filePath) && !filePath.endsWith('.d.ts'),
+  )
+  const sampleToSource = new Map()
+
+  for (const sourceFilePath of sourceFiles) {
+    const samplePath = getTranslationPaths(sourceFilePath)?.samplePath
+
+    if (samplePath && existsSync(samplePath) && !sampleToSource.has(samplePath)) {
+      sampleToSource.set(samplePath, sourceFilePath)
+    }
+  }
+
+  return samplePaths.map((samplePath) => ({
+    samplePath,
+    sourceFilePath: sampleToSource.get(samplePath),
+  }))
+}
+
+export function normalize(input) {
+  return input.trim().toLowerCase().replace(/\s+/g, ' ')
+}
+
+export function shortHash(input) {
+  return createHash('md5').update(input).digest('hex').slice(0, 4)
+}
+
+export function sortJsonValue(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => sortJsonValue(item))
+  }
+
+  if (value && typeof value === 'object') {
+    return Object.fromEntries(
+      Object.entries(value)
+        .sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey))
+        .map(([key, item]) => [key, sortJsonValue(item)]),
+    )
+  }
+
+  return value
+}
+
+export function sortObjectKeys(value) {
+  return Object.fromEntries(Object.entries(value).sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey)))
+}
+
+export function stringifySortedJson(value) {
+  return `${JSON.stringify(sortJsonValue(value), null, 2)}\n`
+}
+
+export function toPageName(input) {
+  return input
+    .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+    .replace(/[-.\s]+/g, '_')
+    .replace(/[^\w$]/g, '')
+    .replace(/_+/g, '_')
+    .replace(/^_+|_+$/g, '')
+    .toLowerCase()
+}
+
+export function toSnake(input) {
+  return input
+    .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+    .replace(/[-.\s]+/g, '_')
+    .replace(/\W/g, '')
+    .replace(/_+/g, '_')
+    .replace(/^_+|_+$/g, '')
+    .toLowerCase()
+}
+
+function getBabelPlugins(id) {
+  const normalizedId = id.replace(/[?#].*$/, '')
+
+  if (/\.(?:jsx|tsx)$/.test(normalizedId)) {
+    return ['typescript', 'jsx']
+  }
+
+  return ['typescript']
+}
+
+function getStaticText(node) {
+  if (!node) {
+    return null
+  }
+
+  if (isStringLiteral(node)) {
+    return node.value
+  }
+
+  if (isTemplateLiteral(node) && node.expressions.length === 0) {
+    return node.quasis.map((quasi) => quasi.value.cooked ?? quasi.value.raw).join('')
+  }
+
+  return null
+}
+
+function isIgnoredSourcePath(id) {
+  return IGNORED_SOURCE_SEGMENTS.some((segment) => id.includes(segment))
+}
+
+function isTCall(node) {
+  const callee = node.callee
+
+  if (isIdentifier(callee) && callee.name === 't') {
+    return true
+  }
+
+  if (isMemberExpression(callee) && isIdentifier(callee.property) && callee.property.name === 't') {
+    if (isIdentifier(callee.object, { name: 'currentI18n' })) {
+      return false
+    }
+
+    return true
+  }
+
+  return false
+}
+
+function isVueSubResourceId(id) {
+  return /[?&]vue&type=/.test(id)
+}
+
+function toPageSegmentName(segment) {
+  const dynamicMatch = segment.match(/^\[([^\]]+)\]$/)
+
+  if (dynamicMatch) {
+    return `$${dynamicMatch[1]}`
+  }
+
+  return toSnake(segment)
+}
+
+function toPascal(input) {
+  return toSnake(input)
+    .split('_')
+    .filter(Boolean)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join('')
+}

package/src/translate-context/index.js

@@ -0,0 +1,3 @@
+import { runAiContextCli } from '../translate/ai-context.js'
+
+await runAiContextCli(process.argv.slice(3))

package/src/translate-sync/index.js

@@ -0,0 +1,25 @@
+const args = process.argv.slice(3)
+
+if (args.includes('--help') || args.includes('-h')) {
+  printHelp()
+  process.exit(0)
+}
+
+if (args.length > 0) {
+  printHelp()
+  process.exit(1)
+}
+
+await import('../translate/sync.js')
+
+function printHelp() {
+  console.log(`brick translate-sync
+
+Usage:
+  brick translate-sync
+
+Notes:
+  Scans source files and regenerates translation sample.json files
+  Removes obsolete generated translation directories
+  Verifies and normalizes translation JSON key ordering`)
+}

package/src/types/index.js

@@ -0,0 +1,127 @@
+import { readdirSync, statSync, writeFileSync } from 'node:fs'
+import path from 'node:path'
+
+const args = process.argv.slice(3)
+
+if (args.includes('--help') || args.includes('-h')) {
+  printHelp()
+  process.exit(0)
+}
+
+const options = parseArgs(args)
+
+if (!options.path || !options.typeName || !options.outputFile || !options.replacePattern) {
+  printHelp()
+  process.exit(1)
+}
+
+const inputDir = path.resolve(process.cwd(), options.path)
+const outputFile = path.resolve(process.cwd(), options.outputFile)
+const replacePattern = parseReplacePattern(options.replacePattern)
+const entries = readdirSync(inputDir)
+  .filter((entry) => statSync(path.join(inputDir, entry)).isFile())
+  .sort((first, second) => first.localeCompare(second))
+
+const typeValues = new Set(entries.map((entry) => applyReplacePattern(entry, replacePattern)).filter(Boolean))
+
+if (typeValues.size === 0) {
+  throw new Error(`No type values generated from: ${inputDir}`)
+}
+
+const declaration = `declare type ${options.typeName} = ${[...typeValues].map((value) => `'${value}'`).join(' | ')}\n`
+writeFileSync(outputFile, declaration, 'utf8')
+
+console.log(`✅ Types generated for ${options.typeName}`)
+console.log(`   input:  ${inputDir}`)
+console.log(`   output: ${outputFile}`)
+
+function applyReplacePattern(value, pattern) {
+  if (pattern instanceof RegExp) {
+    return value.replace(pattern, '')
+  }
+
+  return value.replaceAll(pattern, '')
+}
+
+function parseArgs(rawArgs) {
+  const parsedOptions = {
+    outputFile: null,
+    path: null,
+    replacePattern: null,
+    typeName: null,
+  }
+  const positional = []
+
+  for (let index = 0; index < rawArgs.length; index += 1) {
+    const value = rawArgs[index]
+
+    if (value === '--path') {
+      parsedOptions.path = rawArgs[index + 1] ?? null
+      index += 1
+      continue
+    }
+
+    if (value === '--type-name') {
+      parsedOptions.typeName = rawArgs[index + 1] ?? null
+      index += 1
+      continue
+    }
+
+    if (value === '--output-file') {
+      parsedOptions.outputFile = rawArgs[index + 1] ?? null
+      index += 1
+      continue
+    }
+
+    if (value === '--replace-pattern') {
+      parsedOptions.replacePattern = rawArgs[index + 1] ?? null
+      index += 1
+      continue
+    }
+
+    positional.push(value)
+  }
+
+  if (!parsedOptions.path) {
+    parsedOptions.path = positional[0] ?? null
+  }
+
+  if (!parsedOptions.typeName) {
+    parsedOptions.typeName = positional[1] ?? null
+  }
+
+  if (!parsedOptions.outputFile) {
+    parsedOptions.outputFile = positional[2] ?? null
+  }
+
+  if (!parsedOptions.replacePattern) {
+    parsedOptions.replacePattern = positional[3] ?? null
+  }
+
+  return parsedOptions
+}
+
+function parseReplacePattern(value) {
+  const match = value.match(/^\/([\s\S]*)\/([dgimsuvy]*)$/)
+
+  if (match) {
+    return new RegExp(match[1], match[2])
+  }
+
+  return value
+}
+
+function printHelp() {
+  console.log(`brick types <path> <typeName> <outputFile> <replacePattern>
+
+Usage:
+  brick types ./path/to/files IconName ./types/icon.d.ts .svg
+  brick types ./path/to/files IconName ./types/icon.d.ts /\\.svg$/
+  brick types --path ./path/to/files --type-name IconName --output-file ./types/icon.d.ts --replace-pattern /\\.svg$/
+
+Notes:
+  path: directory with source files
+  typeName: generated TypeScript type name
+  outputFile: file to write declaration into
+  replacePattern: string or regex literal used in replace(..., '') for each filename`)
+}