@atproto/lex-builder 0.1.4 → 0.1.5

package/src/ts-lang.ts

@@ -1,197 +0,0 @@
-/**
- * Set of JavaScript reserved keywords and future reserved words.
- *
- * These identifiers cannot be used as variable or type names in generated code.
- *
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar}
- */
-const JS_KEYWORDS = new Set([
-  'abstract',
-  'arguments',
-  'as',
-  'async',
-  'await',
-  'boolean',
-  'break',
-  'byte',
-  'case',
-  'catch',
-  'char',
-  'class',
-  'const',
-  'continue',
-  'debugger',
-  'default',
-  'delete',
-  'do',
-  'double',
-  'else',
-  'enum',
-  'eval',
-  'export',
-  'extends',
-  'false',
-  'final',
-  'finally',
-  'float',
-  'for',
-  'from',
-  'function',
-  'get',
-  'goto',
-  'if',
-  'implements',
-  'import',
-  'in',
-  'instanceof',
-  'int',
-  'interface',
-  'let',
-  'long',
-  'native',
-  'new',
-  'null',
-  'of',
-  'package',
-  'private',
-  'protected',
-  'public',
-  'return',
-  'set',
-  'short',
-  'static',
-  'super',
-  'switch',
-  'synchronized',
-  'this',
-  'throw',
-  'throws',
-  'transient',
-  'true',
-  'try',
-  'typeof',
-  'undefined',
-  'using',
-  'var',
-  'void',
-  'volatile',
-  'while',
-  'with',
-  'yield',
-])
-
-/**
- * Checks if a word is a JavaScript reserved keyword.
- *
- * @param word - The identifier to check
- * @returns `true` if the word is a reserved keyword
- */
-export function isJsKeyword(word: string) {
-  return JS_KEYWORDS.has(word)
-}
-
-// Only important to list var/type names that are likely to be used in the
-// generated code files.
-const GLOBAL_IDENTIFIERS = new Set([
-  // import { l } from "@atproto/lex-schema"
-  'l',
-  // JS Globals
-  'self',
-  'globalThis',
-  // ESM
-  'import',
-  // CommonJS
-  '__dirname',
-  '__filename',
-  'require',
-  'module',
-  'exports',
-  // TS Primitives
-  'any',
-  'bigint',
-  'boolean',
-  'declare',
-  'never',
-  'null',
-  'number',
-  'object',
-  'string',
-  'symbol',
-  'undefined',
-  'unknown',
-  'void',
-  // TS Utility types
-  'Record',
-  'Partial',
-  'Readonly',
-  'Pick',
-  'Omit',
-  'Exclude',
-  'Extract',
-  'InstanceType',
-  'ReturnType',
-  'Required',
-  'ThisType',
-  'Uppercase',
-  'Lowercase',
-  'Capitalize',
-  'Uncapitalize',
-])
-
-/**
- * Checks if a word is a global identifier that should be avoided.
- *
- * This includes JavaScript globals, TypeScript built-in types, and
- * identifiers commonly used in the generated code.
- *
- * @param word - The identifier to check
- * @returns `true` if the word is a global identifier
- */
-export function isGlobalIdentifier(word: string) {
-  return GLOBAL_IDENTIFIERS.has(word)
-}
-
-/**
- * Checks if a name is safe to use as a local identifier.
- *
- * A safe local identifier is a valid JavaScript identifier that does not
- * conflict with global identifiers.
- *
- * @param name - The identifier to check
- * @returns `true` if the name is safe to use locally
- */
-export function isSafeLocalIdentifier(name: string) {
-  return !isGlobalIdentifier(name) && isValidJsIdentifier(name)
-}
-
-/**
- * Checks if a name is a valid JavaScript identifier.
- *
- * Valid identifiers start with a letter, underscore, or dollar sign,
- * followed by any combination of letters, digits, underscores, or dollar
- * signs. Reserved keywords are not valid identifiers.
- *
- * @param name - The string to check
- * @returns `true` if the name is a valid identifier
- */
-export function isValidJsIdentifier(name: string) {
-  return (
-    name.length > 0 &&
-    !isJsKeyword(name) &&
-    /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name)
-  )
-}
-
-/**
- * Converts a name to a valid namespace export identifier.
- *
- * If the name is a valid JavaScript identifier, it is returned as-is.
- * Otherwise, it is returned as a quoted string for use in export statements
- * like `export { foo as "unsafe-name" }`.
- *
- * @param name - The export name
- * @returns The name as a valid export identifier
- */
-export function asNamespaceExport(name: string) {
-  return isValidJsIdentifier(name) ? name : JSON.stringify(name)
-}

package/src/util.ts

@@ -1,72 +0,0 @@
-import { relative } from 'node:path'
-
-export function memoize<T extends (arg: string) => NonNullable<unknown> | null>(
-  fn: T,
-): T {
-  const cache = new Map<string, NonNullable<unknown> | null>()
-  return ((arg: string) => {
-    const cached = cache.get(arg)
-    if (cached !== undefined) return cached
-    const result = fn(arg)
-    cache.set(arg, result)
-    return result
-  }) as T
-}
-
-export function startsWithLower(str: string) {
-  const code = str.charCodeAt(0)
-  return code >= 97 && code <= 122 // 'a' to 'z'
-}
-
-export function ucFirst(str: string) {
-  return str.charAt(0).toUpperCase() + str.slice(1)
-}
-
-export function lcFirst(str: string) {
-  return str.charAt(0).toLowerCase() + str.slice(1)
-}
-
-export function toPascalCase(str: string): string {
-  return extractWords(str).map(toLowerCase).map(ucFirst).join('')
-}
-
-export function toCamelCase(str: string): string {
-  return lcFirst(toPascalCase(str))
-}
-
-export function toConstantCase(str: string): string {
-  return extractWords(str).map(toUpperCase).join('_')
-}
-
-export function toLowerCase(str: string): string {
-  return str.toLowerCase()
-}
-
-export function toUpperCase(str: string): string {
-  return str.toUpperCase()
-}
-
-function extractWords(str: string): string[] {
-  const processedStr = str
-    .replace(/([a-z0-9])([A-Z])/g, '$1 $2') // split camelCase
-    .replace(/([A-Z])([A-Z][a-z])/g, '$1 $2') // split ALLCAPSWords
-    .replace(/([0-9])([A-Za-z])/g, '$1 $2') // split number followed by letter
-    .replace(/[^a-zA-Z0-9]+/g, ' ') // replace non-alphanumeric with space
-    .trim() // trim leading/trailing spaces
-
-  return processedStr
-    ? processedStr.split(/\s+/) // split by spaces
-    : [] // Avoid returning [''] for empty strings
-}
-
-export function asRelativePath(from: string, to: string) {
-  const relPath = relative(from, to)
-  return relPath.startsWith('./') || relPath.startsWith('../')
-    ? relPath
-    : `./${relPath}`
-}
-
-export function startsWithDigit(str: string) {
-  const code = str.charCodeAt(0)
-  return code >= 48 && code <= 57 // '0' to '9'
-}

package/tsconfig.build.json

@@ -1,13 +0,0 @@
-{
-  "extends": ["../../../tsconfig/node.json"],
-  "include": ["./src"],
-  "exclude": ["**/*.test.ts"],
-  "compilerOptions": {
-    "noImplicitAny": true,
-    "importHelpers": true,
-    "target": "ES2023",
-    "rootDir": "./src",
-    "outDir": "./dist",
-    "types": ["node"],
-  },
-}

package/tsconfig.json

@@ -1,7 +0,0 @@
-{
-  "include": [],
-  "references": [
-    { "path": "./tsconfig.build.json" },
-    { "path": "./tsconfig.tests.json" },
-  ],
-}

package/tsconfig.tests.json

@@ -1,8 +0,0 @@
-{
-  "extends": "../../../tsconfig/vitest.json",
-  "include": ["./tests", "./src/**/*.test.ts"],
-  "compilerOptions": {
-    "noImplicitAny": true,
-    "rootDir": "./",
-  },
-}