apdev-js 0.1.1 → 0.2.1

package/dist/index.js

@@ -6,82 +6,102 @@ var getDirname = () => path.dirname(getFilename());
 var __dirname = /* @__PURE__ */ getDirname();
 
 // src/check-chars.ts
-import { readFileSync } from "fs";
-import { extname } from "path";
-var EMOJI_RANGES = [
-  [127744, 128511],
-  // Symbols and Pictographs
-  [128512, 128591],
-  // Emoticons
-  [128640, 128767],
-  // Transport and Map Symbols
-  [128896, 129023],
-  // Geometric Shapes Extended
-  [129280, 129535],
-  // Supplemental Symbols and Pictographs
-  [9728, 9983],
-  // Miscellaneous Symbols
-  [9984, 10175]
-  // Dingbats
-];
-var EXTRA_ALLOWED_RANGES = [
-  [128, 255],
-  // Latin-1 Supplement
-  [8192, 8303],
-  // General Punctuation
-  [8448, 8527],
-  // Letterlike Symbols
-  [8592, 8703],
-  // Arrows
-  [8704, 8959],
-  // Mathematical Operators
-  [8960, 9215],
-  // Miscellaneous Technical
-  [9472, 9599],
-  // Box Drawing
-  [9632, 9727],
-  // Geometric Shapes
-  [11008, 11263],
-  // Miscellaneous Symbols and Arrows
-  [65024, 65039]
-  // Variation Selectors
-];
-var ALL_RANGES = [...EMOJI_RANGES, ...EXTRA_ALLOWED_RANGES];
-var DANGEROUS_CODEPOINTS = /* @__PURE__ */ new Map([
-  // Bidi control characters (Trojan Source - CVE-2021-42574)
-  [8234, "LEFT-TO-RIGHT EMBEDDING"],
-  [8235, "RIGHT-TO-LEFT EMBEDDING"],
-  [8236, "POP DIRECTIONAL FORMATTING"],
-  [8237, "LEFT-TO-RIGHT OVERRIDE"],
-  [8238, "RIGHT-TO-LEFT OVERRIDE"],
-  [8294, "LEFT-TO-RIGHT ISOLATE"],
-  [8295, "RIGHT-TO-LEFT ISOLATE"],
-  [8296, "FIRST STRONG ISOLATE"],
-  [8297, "POP DIRECTIONAL ISOLATE"],
-  // Zero-width characters
-  [8203, "ZERO WIDTH SPACE"],
-  [8204, "ZERO WIDTH NON-JOINER"],
-  [8205, "ZERO WIDTH JOINER"],
-  [8206, "LEFT-TO-RIGHT MARK"],
-  [8207, "RIGHT-TO-LEFT MARK"],
-  [8288, "WORD JOINER"]
-]);
-var PYTHON_SUFFIXES = /* @__PURE__ */ new Set([".py"]);
-var JS_SUFFIXES = /* @__PURE__ */ new Set([".js", ".ts", ".tsx", ".jsx", ".mjs", ".cjs"]);
-function isAllowedChar(c) {
-  const code = c.codePointAt(0);
-  if (code <= 127) {
-    return true;
+import { readFileSync, existsSync, readdirSync, statSync } from "fs";
+import { extname, dirname, join, sep } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function getCharsetsDir() {
+  const thisDir = typeof __dirname !== "undefined" ? __dirname : dirname(fileURLToPath2(import.meta.url));
+  const devPath = join(thisDir, "charsets");
+  if (existsSync(devPath)) {
+    return devPath;
+  }
+  return join(thisDir, "..", "src", "charsets");
+}
+function loadCharset(nameOrPath) {
+  if (nameOrPath.includes(sep) || nameOrPath.includes("/") || nameOrPath.endsWith(".json")) {
+    if (!existsSync(nameOrPath)) {
+      throw new Error(`Charset file not found: ${nameOrPath}`);
+    }
+    return JSON.parse(readFileSync(nameOrPath, "utf-8"));
+  }
+  const filePath = join(getCharsetsDir(), `${nameOrPath}.json`);
+  if (!existsSync(filePath)) {
+    throw new Error(`Unknown charset: ${nameOrPath}`);
+  }
+  return JSON.parse(readFileSync(filePath, "utf-8"));
+}
+function parseRanges(entries) {
+  return entries.map((e) => [parseInt(e.start, 16), parseInt(e.end, 16)]);
+}
+function parseDangerous(entries) {
+  const map = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    map.set(parseInt(e.code, 16), e.name);
   }
-  for (const [start, end] of ALL_RANGES) {
-    if (code >= start && code <= end) {
-      return true;
+  return map;
+}
+function resolveCharsets(charsetNames, charsetFiles) {
+  const base = loadCharset("base");
+  const rangesSet = /* @__PURE__ */ new Map();
+  const dangerous = parseDangerous(base.dangerous ?? []);
+  function addRanges(entries) {
+    for (const [s, e] of parseRanges(entries)) {
+      rangesSet.set(`${s}-${e}`, [s, e]);
     }
   }
+  addRanges(base.emoji_ranges ?? []);
+  addRanges(base.extra_ranges ?? []);
+  for (const name of charsetNames) {
+    const data = loadCharset(name);
+    addRanges(data.emoji_ranges ?? []);
+    addRanges(data.extra_ranges ?? []);
+    if (data.dangerous) {
+      for (const [code, dname] of parseDangerous(data.dangerous)) {
+        dangerous.set(code, dname);
+      }
+    }
+  }
+  for (const path2 of charsetFiles) {
+    const data = loadCharset(path2);
+    addRanges(data.emoji_ranges ?? []);
+    addRanges(data.extra_ranges ?? []);
+    if (data.dangerous) {
+      for (const [code, dname] of parseDangerous(data.dangerous)) {
+        dangerous.set(code, dname);
+      }
+    }
+  }
+  const ranges = [...rangesSet.values()].sort((a, b) => a[0] - b[0]);
+  return { ranges, dangerous };
+}
+var PYTHON_SUFFIXES = /* @__PURE__ */ new Set([".py"]);
+var JS_SUFFIXES = /* @__PURE__ */ new Set([".js", ".ts", ".tsx", ".jsx", ".mjs", ".cjs"]);
+function isInRanges(code, ranges) {
+  if (code <= 127) return true;
+  for (const [start, end] of ranges) {
+    if (code >= start && code <= end) return true;
+  }
   return false;
 }
+var _baseRanges = null;
+var _baseDangerous = null;
+function getBaseDefaults() {
+  if (!_baseRanges || !_baseDangerous) {
+    const defaults = resolveCharsets([], []);
+    _baseRanges = defaults.ranges;
+    _baseDangerous = defaults.dangerous;
+  }
+  return { ranges: _baseRanges, dangerous: _baseDangerous };
+}
+function isAllowedChar(c) {
+  const { ranges, dangerous } = getBaseDefaults();
+  const code = c.codePointAt(0);
+  if (dangerous.has(code)) return false;
+  return isInRanges(code, ranges);
+}
 function isDangerousChar(c) {
-  return DANGEROUS_CODEPOINTS.has(c.codePointAt(0));
+  const { dangerous } = getBaseDefaults();
+  return dangerous.has(c.codePointAt(0));
 }
 function computeCommentMask(content, suffix) {
   if (PYTHON_SUFFIXES.has(suffix)) {
@@ -200,8 +220,13 @@ function computeCommentMaskJs(content) {
   }
   return mask;
 }
-function checkFile(filePath, maxProblems = 5) {
+function checkFile(filePath, maxProblems = 5, extraRanges, dangerousMap) {
   const problems = [];
+  if (!extraRanges || !dangerousMap) {
+    const defaults = getBaseDefaults();
+    extraRanges ??= defaults.ranges;
+    dangerousMap ??= defaults.dangerous;
+  }
   try {
     const content = readFileSync(filePath, "utf-8");
     const suffix = extname(filePath).toLowerCase();
@@ -211,15 +236,15 @@ function checkFile(filePath, maxProblems = 5) {
     for (const char of content) {
       position++;
       const code = char.codePointAt(0);
-      if (isDangerousChar(char)) {
+      if (dangerousMap.has(code)) {
         if (!commentMask.has(offset)) {
-          const name = DANGEROUS_CODEPOINTS.get(code);
+          const name = dangerousMap.get(code);
           const hex = code.toString(16).toUpperCase().padStart(4, "0");
           problems.push(
             `Dangerous character in code at position ${position}: U+${hex} (${name})`
           );
         }
-      } else if (!isAllowedChar(char)) {
+      } else if (!isInRanges(code, extraRanges)) {
         const hex = code.toString(16).toUpperCase().padStart(4, "0");
         problems.push(
           `Illegal character at position ${position}: ${JSON.stringify(char)} (U+${hex})`
@@ -230,15 +255,169 @@ function checkFile(filePath, maxProblems = 5) {
       }
       offset += char.length;
     }
-  } catch {
-    problems.push(`Failed to read file: ${filePath}`);
+  } catch (e) {
+    problems.push(`Failed to read file: ${filePath} (${e})`);
   }
   return problems;
 }
-function checkPaths(paths) {
+var SKIP_SUFFIXES = /* @__PURE__ */ new Set([
+  // Bytecode
+  ".pyc",
+  ".pyo",
+  // Images
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".bmp",
+  ".ico",
+  ".svg",
+  ".webp",
+  // Fonts
+  ".ttf",
+  ".otf",
+  ".woff",
+  ".woff2",
+  ".eot",
+  // Archives
+  ".zip",
+  ".tar",
+  ".gz",
+  ".bz2",
+  ".xz",
+  ".7z",
+  // Compiled / binary
+  ".so",
+  ".dylib",
+  ".dll",
+  ".exe",
+  ".o",
+  ".a",
+  ".whl",
+  ".egg",
+  // Media
+  ".mp3",
+  ".mp4",
+  ".wav",
+  ".avi",
+  ".mov",
+  ".flac",
+  ".ogg",
+  // Documents
+  ".pdf",
+  ".doc",
+  ".docx",
+  ".xls",
+  ".xlsx",
+  ".ppt",
+  ".pptx",
+  // Data
+  ".db",
+  ".sqlite",
+  ".sqlite3",
+  ".pickle",
+  ".pkl"
+]);
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "__pycache__",
+  "node_modules",
+  ".git",
+  ".venv",
+  "venv",
+  ".tox",
+  ".mypy_cache",
+  ".pytest_cache",
+  ".ruff_cache",
+  "dist",
+  "build"
+]);
+var DEFAULT_DIRS = ["src", "tests", "examples"];
+var DEFAULT_GLOBS = ["*.md", "*.yml", "*.yaml", "*.json", ".gitignore"];
+function walkDir(directory) {
+  const files = [];
+  let entries;
+  try {
+    entries = readdirSync(directory).sort();
+  } catch {
+    return files;
+  }
+  for (const name of entries) {
+    if (name.startsWith(".")) continue;
+    const fullPath = join(directory, name);
+    let stat;
+    try {
+      stat = statSync(fullPath);
+    } catch {
+      continue;
+    }
+    if (stat.isDirectory()) {
+      if (SKIP_DIRS.has(name) || name.endsWith(".egg-info")) continue;
+      files.push(...walkDir(fullPath));
+    } else if (stat.isFile()) {
+      if (SKIP_SUFFIXES.has(extname(name).toLowerCase())) continue;
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+function defaultProjectFiles() {
+  const cwd = process.cwd();
+  const files = [];
+  for (const dirname3 of DEFAULT_DIRS) {
+    const d = join(cwd, dirname3);
+    if (existsSync(d) && statSync(d).isDirectory()) {
+      files.push(...walkDir(d));
+    }
+  }
+  for (const pattern of DEFAULT_GLOBS) {
+    if (pattern.startsWith("*.")) {
+      const suffix = pattern.slice(1);
+      try {
+        for (const name of readdirSync(cwd).sort()) {
+          if (name.endsWith(suffix) && statSync(join(cwd, name)).isFile()) {
+            files.push(join(cwd, name));
+          }
+        }
+      } catch {
+      }
+    } else {
+      const fullPath = join(cwd, pattern);
+      if (existsSync(fullPath) && statSync(fullPath).isFile()) {
+        files.push(fullPath);
+      }
+    }
+  }
+  return files;
+}
+function resolvePaths(paths) {
+  if (paths.length === 0) {
+    return defaultProjectFiles();
+  }
+  const result = [];
+  for (const p of paths) {
+    try {
+      if (statSync(p).isDirectory()) {
+        result.push(...walkDir(p));
+      } else {
+        result.push(p);
+      }
+    } catch {
+      result.push(p);
+    }
+  }
+  return result;
+}
+function checkPaths(paths, extraRanges, dangerousMap) {
+  const resolved = resolvePaths(paths);
+  if (resolved.length === 0) {
+    console.log("No files to check.");
+    return 0;
+  }
   let hasError = false;
-  for (const path2 of paths) {
-    const problems = checkFile(path2);
+  let checked = 0;
+  for (const path2 of resolved) {
+    const problems = checkFile(path2, 5, extraRanges, dangerousMap);
+    checked++;
     if (problems.length > 0) {
       hasError = true;
       console.log(`
@@ -248,12 +427,15 @@ ${path2} contains illegal characters:`);
       }
     }
   }
+  if (!hasError) {
+    console.log(`All ${checked} files passed.`);
+  }
   return hasError ? 1 : 0;
 }
 
 // src/check-imports.ts
-import { readFileSync as readFileSync2, readdirSync, statSync } from "fs";
-import { join, relative, sep, extname as extname2, basename } from "path";
+import { readFileSync as readFileSync2, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { join as join2, relative, sep as sep2, extname as extname2, basename } from "path";
 import ts from "typescript";
 var SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([
   ".ts",
@@ -273,7 +455,7 @@ var INDEX_BASENAMES = /* @__PURE__ */ new Set([
 ]);
 function fileToModule(filePath, srcDir) {
   const rel = relative(srcDir, filePath);
-  const parts = rel.split(sep);
+  const parts = rel.split(sep2);
   const last = parts[parts.length - 1];
   if (last === "index.ts" || last === "index.js" || last === "index.tsx" || last === "index.jsx") {
     parts.pop();
@@ -341,13 +523,13 @@ function resolveImports(rawImports, basePackage, currentModule, isPackage) {
 function findSourceFiles(dir) {
   const results = [];
   function walk(d) {
-    const entries = readdirSync(d);
+    const entries = readdirSync2(d);
     for (const entry of entries) {
       if (entry === "node_modules" || entry === "dist" || entry === ".git") {
         continue;
       }
-      const full = join(d, entry);
-      const stat = statSync(full);
+      const full = join2(d, entry);
+      const stat = statSync2(full);
       if (stat.isDirectory()) {
         walk(full);
       } else if (SUPPORTED_EXTENSIONS.has(extname2(entry))) {
@@ -435,7 +617,7 @@ function findCycles(graph) {
 function checkCircularImports(srcDir, basePackage) {
   let stat;
   try {
-    stat = statSync(srcDir);
+    stat = statSync2(srcDir);
   } catch {
     console.error(`Error: ${srcDir}/ directory not found`);
     return 1;
@@ -463,10 +645,10 @@ Found ${cycles.length} circular import(s):
 
 // src/config.ts
 import { readFileSync as readFileSync3 } from "fs";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 function loadConfig(projectDir) {
   const dir = projectDir ?? process.cwd();
-  const pkgPath = join2(dir, "package.json");
+  const pkgPath = join3(dir, "package.json");
   let raw;
   try {
     raw = readFileSync3(pkgPath, "utf-8");
@@ -483,12 +665,12 @@ function loadConfig(projectDir) {
 
 // src/index.ts
 import { readFileSync as readFileSync4 } from "fs";
-import { dirname, join as join3 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname2, join as join4 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
 function readVersion() {
-  const thisDir = typeof __dirname !== "undefined" ? __dirname : dirname(fileURLToPath2(import.meta.url));
+  const thisDir = typeof __dirname !== "undefined" ? __dirname : dirname2(fileURLToPath3(import.meta.url));
   try {
-    const pkg = JSON.parse(readFileSync4(join3(thisDir, "..", "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync4(join4(thisDir, "..", "package.json"), "utf-8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -503,6 +685,10 @@ export {
   fileToModule,
   findCycles,
   isAllowedChar,
+  isDangerousChar,
+  loadCharset,
   loadConfig,
+  resolveCharsets,
+  resolvePaths,
   version
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "apdev-js",
-  "version": "0.1.1",
-  "description": "Shared development tools for TypeScript/JavaScript projects - character validation, circular import detection, and more",
+  "version": "0.2.1",
+  "description": "General-purpose development tools for TypeScript/JavaScript projects - character validation, circular import detection, and more",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
@@ -18,7 +18,8 @@
   },
   "files": [
     "dist",
-    "release.sh"
+    "release.sh",
+    "src/charsets"
   ],
   "scripts": {
     "build": "tsup",
@@ -30,9 +31,16 @@
   },
   "keywords": [
     "development-tools",
+    "quality-assurance",
+    "linting",
+    "static-analysis",
     "character-validation",
     "circular-imports",
-    "linting"
+    "release-automation",
+    "unicode-checker",
+    "trojan-source-detection",
+    "typescript",
+    "javascript"
   ],
   "author": "aipartnerup <tercel.yi@gmail.com>",
   "license": "Apache-2.0",
@@ -46,12 +54,20 @@
     "url": "https://github.com/aipartnerup/apdev/issues"
   },
   "dependencies": {
-    "commander": "^13.0.0",
-    "typescript": "^5.7.0"
+    "commander": "^13.0.0"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
     "tsup": "^8.0.0",
+    "typescript": "^5.7.0",
     "vitest": "^3.0.0"
   }
-}
+}

package/src/charsets/base.json

@@ -0,0 +1,44 @@
+{
+  "name": "base",
+  "description": "Default: ASCII + emoji + technical symbols",
+  "emoji_ranges": [
+    { "start": "0x1F300", "end": "0x1F5FF", "name": "Symbols and Pictographs" },
+    { "start": "0x1F600", "end": "0x1F64F", "name": "Emoticons" },
+    { "start": "0x1F680", "end": "0x1F6FF", "name": "Transport and Map Symbols" },
+    { "start": "0x1F780", "end": "0x1F7FF", "name": "Geometric Shapes Extended" },
+    { "start": "0x1F900", "end": "0x1F9FF", "name": "Supplemental Symbols and Pictographs" },
+    { "start": "0x2600", "end": "0x26FF", "name": "Miscellaneous Symbols" },
+    { "start": "0x2700", "end": "0x27BF", "name": "Dingbats" }
+  ],
+  "extra_ranges": [
+    { "start": "0x0080", "end": "0x00FF", "name": "Latin-1 Supplement" },
+    { "start": "0x2000", "end": "0x206F", "name": "General Punctuation" },
+    { "start": "0x2100", "end": "0x214F", "name": "Letterlike Symbols" },
+    { "start": "0x2190", "end": "0x21FF", "name": "Arrows" },
+    { "start": "0x2200", "end": "0x22FF", "name": "Mathematical Operators" },
+    { "start": "0x2300", "end": "0x23FF", "name": "Miscellaneous Technical" },
+    { "start": "0x2500", "end": "0x257F", "name": "Box Drawing" },
+    { "start": "0x2580", "end": "0x259F", "name": "Block Elements" },
+    { "start": "0x25A0", "end": "0x25FF", "name": "Geometric Shapes" },
+    { "start": "0x2800", "end": "0x28FF", "name": "Braille Patterns" },
+    { "start": "0x2B00", "end": "0x2BFF", "name": "Miscellaneous Symbols and Arrows" },
+    { "start": "0xFE00", "end": "0xFE0F", "name": "Variation Selectors" }
+  ],
+  "dangerous": [
+    { "code": "0x202A", "name": "LEFT-TO-RIGHT EMBEDDING" },
+    { "code": "0x202B", "name": "RIGHT-TO-LEFT EMBEDDING" },
+    { "code": "0x202C", "name": "POP DIRECTIONAL FORMATTING" },
+    { "code": "0x202D", "name": "LEFT-TO-RIGHT OVERRIDE" },
+    { "code": "0x202E", "name": "RIGHT-TO-LEFT OVERRIDE" },
+    { "code": "0x2066", "name": "LEFT-TO-RIGHT ISOLATE" },
+    { "code": "0x2067", "name": "RIGHT-TO-LEFT ISOLATE" },
+    { "code": "0x2068", "name": "FIRST STRONG ISOLATE" },
+    { "code": "0x2069", "name": "POP DIRECTIONAL ISOLATE" },
+    { "code": "0x200B", "name": "ZERO WIDTH SPACE" },
+    { "code": "0x200C", "name": "ZERO WIDTH NON-JOINER" },
+    { "code": "0x200D", "name": "ZERO WIDTH JOINER" },
+    { "code": "0x200E", "name": "LEFT-TO-RIGHT MARK" },
+    { "code": "0x200F", "name": "RIGHT-TO-LEFT MARK" },
+    { "code": "0x2060", "name": "WORD JOINER" }
+  ]
+}

package/src/charsets/chinese.json

@@ -0,0 +1,9 @@
+{
+  "name": "chinese",
+  "description": "Chinese: CJK Unified Ideographs, CJK Punctuation, Fullwidth Forms",
+  "extra_ranges": [
+    { "start": "0x3000", "end": "0x303F", "name": "CJK Symbols and Punctuation" },
+    { "start": "0x4E00", "end": "0x9FFF", "name": "CJK Unified Ideographs" },
+    { "start": "0xFF00", "end": "0xFFEF", "name": "Fullwidth Forms" }
+  ]
+}

package/src/charsets/japanese.json

@@ -0,0 +1,11 @@
+{
+  "name": "japanese",
+  "description": "Japanese: Hiragana, Katakana, CJK Unified Ideographs, CJK Punctuation, Fullwidth Forms",
+  "extra_ranges": [
+    { "start": "0x3000", "end": "0x303F", "name": "CJK Symbols and Punctuation" },
+    { "start": "0x3040", "end": "0x309F", "name": "Hiragana" },
+    { "start": "0x30A0", "end": "0x30FF", "name": "Katakana" },
+    { "start": "0x4E00", "end": "0x9FFF", "name": "CJK Unified Ideographs" },
+    { "start": "0xFF00", "end": "0xFFEF", "name": "Fullwidth Forms" }
+  ]
+}

package/src/charsets/korean.json

@@ -0,0 +1,11 @@
+{
+  "name": "korean",
+  "description": "Korean: Hangul Jamo, Hangul Syllables, CJK Unified Ideographs, CJK Punctuation, Fullwidth Forms",
+  "extra_ranges": [
+    { "start": "0x1100", "end": "0x11FF", "name": "Hangul Jamo" },
+    { "start": "0x3000", "end": "0x303F", "name": "CJK Symbols and Punctuation" },
+    { "start": "0x4E00", "end": "0x9FFF", "name": "CJK Unified Ideographs" },
+    { "start": "0xAC00", "end": "0xD7AF", "name": "Hangul Syllables" },
+    { "start": "0xFF00", "end": "0xFFEF", "name": "Fullwidth Forms" }
+  ]
+}