@esportsplus/typescript 0.9.2 → 0.11.0

package/.github/workflows/bump.yml

@@ -1,9 +1,27 @@
-name: bump
+name: bump version
 
 on:
   push:
     branches: '**' # only trigger on branches, not on tags
+  workflow_call:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: write
 
 jobs:
   bump:
-    uses: esportsplus/workflows/.github/workflows/bump.yml@main
+    runs-on: ubuntu-latest
+    steps:
+      - name: checkout repo
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: bump version
+        uses: jpb06/bump-package@latest
+        with:
+          minor-keywords: feat,minor,refactor
+          patch-keywords: fix,chore

package/.github/workflows/dependabot.yml

@@ -3,10 +3,56 @@ name: dependabot automerge
 on:
   pull_request:
     types: [opened, synchronize, labeled]
-  workflow_dispatch:
+  workflow_call:
+    secrets:
+      NPM_TOKEN:
+        required: true
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: write
+  pull-requests: write
 
 jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v4
+        name: Install pnpm
+        with:
+          run_install: false
+          version: latest
+      - uses: actions/setup-node@v4
+        with:
+          cache: 'pnpm'
+          node-version: 'latest'
+          registry-url: 'https://registry.npmjs.org'
+      - run: pnpm i && pnpm build
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+
   automerge:
-    secrets:
-      NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
-    uses: esportsplus/workflows/.github/workflows/dependabot.yml@main
+    needs: build
+    permissions:
+      pull-requests: write
+      contents: write
+    runs-on: ubuntu-latest
+    if: ${{ github.actor == 'dependabot[bot]' && github.event_name == 'pull_request' }}
+    steps:
+      - uses: dependabot/fetch-metadata@v2
+        id: metadata
+        with:
+          alert-lookup: true
+          compat-lookup: true
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+      - name: Approve and merge Dependabot PR
+        run: |
+          gh pr review --approve "$PR_URL"
+          gh pr merge --squash --auto "$PR_URL"
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          PR_URL: ${{ github.event.pull_request.html_url }}

package/.github/workflows/publish.yml

@@ -3,14 +3,41 @@ name: publish to npm
 on:
   release:
     types: [published]
+  workflow_call:
+    secrets:
+      NPM_TOKEN:
+        required: true
   workflow_dispatch:
   workflow_run:
-    workflows: [bump]
+    workflows: [bump version]
     types:
       - completed
 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
-  publish:
-    secrets:
-        NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN_PUBLISHING }}
-    uses: esportsplus/workflows/.github/workflows/publish.yml@main
+  build:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v4
+        name: Install pnpm
+        with:
+          run_install: false
+          version: latest
+      - uses: actions/setup-node@v4
+        with:
+          cache: 'pnpm'
+          node-version: 'latest'
+          registry-url: 'https://registry.npmjs.org'
+      - run: pnpm config delete always-auth
+      - run: pnpm i
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+      - run: pnpm build
+      - run: pnpm publish --provenance --no-git-checks

package/.github/workflows/templates/bump.yml

@@ -0,0 +1,9 @@
+name: bump version
+
+on:
+  push:
+    branches: '**' # only trigger on branches, not on tags
+
+jobs:
+  bump:
+    uses: esportsplus/typescript/.github/workflows/bump.yml@main

package/.github/workflows/templates/dependabot.yml

@@ -0,0 +1,12 @@
+name: dependabot automerge
+
+on:
+  pull_request:
+    types: [opened, synchronize, labeled]
+  workflow_dispatch:
+
+jobs:
+  automerge:
+    secrets:
+      NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+    uses: esportsplus/typescript/.github/workflows/dependabot.yml@main

package/.github/workflows/templates/publish.yml

@@ -0,0 +1,16 @@
+name: publish to npm
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+  workflow_run:
+    workflows: [bump version]
+    types:
+      - completed
+
+jobs:
+  publish:
+    secrets:
+        NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+    uses: esportsplus/typescript/.github/workflows/publish.yml@main

package/build/transformer/constants.d.ts

@@ -0,0 +1,4 @@
+declare const BRACES_CONTENT_REGEX: RegExp;
+declare const REGEX_ESCAPE_PATTERN: RegExp;
+declare const UUID_DASH_REGEX: RegExp;
+export { BRACES_CONTENT_REGEX, REGEX_ESCAPE_PATTERN, UUID_DASH_REGEX };

package/build/transformer/constants.js

@@ -0,0 +1,4 @@
+const BRACES_CONTENT_REGEX = /\{([^}]*)\}/;
+const REGEX_ESCAPE_PATTERN = /[.*+?^${}()|[\]\\]/g;
+const UUID_DASH_REGEX = /-/g;
+export { BRACES_CONTENT_REGEX, REGEX_ESCAPE_PATTERN, UUID_DASH_REGEX };

package/build/transformer/index.d.ts

@@ -0,0 +1,13 @@
+import ts from 'typescript';
+import type { ImportModification, NodeMatch, QuickCheckPattern, Replacement, VisitorCallback, VisitorPredicate } from './types.js';
+declare const addImport: (code: string, module: string, specifiers: string[]) => string;
+declare const applyReplacements: (code: string, replacements: Replacement[]) => string;
+declare const applyReplacementsReverse: (code: string, replacements: Replacement[]) => string;
+declare const collectNodes: <T>(sourceFile: ts.SourceFile, predicate: (node: ts.Node) => T | null) => NodeMatch<T>[];
+declare const mightNeedTransform: (code: string, check: QuickCheckPattern) => boolean;
+declare const uid: (prefix?: string) => string;
+declare const updateImports: (code: string, modification: ImportModification) => string;
+declare const visitAst: <T>(sourceFile: ts.SourceFile, callback: VisitorCallback<T>, state: T, predicate?: VisitorPredicate) => T;
+declare const visitAstWithDepth: <T>(sourceFile: ts.SourceFile, callback: (node: ts.Node, depth: number, state: T) => void, state: T, depthTrigger: (node: ts.Node) => boolean) => T;
+export { addImport, applyReplacements, applyReplacementsReverse, collectNodes, mightNeedTransform, uid, updateImports, visitAst, visitAstWithDepth };
+export type { ImportModification, NodeMatch, QuickCheckPattern, Replacement, VisitorCallback, VisitorPredicate };

package/build/transformer/index.js

@@ -0,0 +1,157 @@
+import { uuid } from '@esportsplus/utilities';
+import ts from 'typescript';
+import { BRACES_CONTENT_REGEX, REGEX_ESCAPE_PATTERN, UUID_DASH_REGEX } from './constants.js';
+function buildImportRegex(escapedModule) {
+    return new RegExp(`(import\\s*\\{[^}]*\\}\\s*from\\s*['"]${escapedModule}['"])`);
+}
+function mergeAndSort(a, b) {
+    let combined = new Array(a.length + b.size), idx = 0, n = a.length;
+    for (let i = 0; i < n; i++) {
+        if (a[i]) {
+            combined[idx++] = a[i];
+        }
+    }
+    for (let item of b) {
+        if (item) {
+            combined[idx++] = item;
+        }
+    }
+    combined.length = idx;
+    combined.sort();
+    return combined.join(', ');
+}
+function parseSpecifiers(str) {
+    let parts = str.split(','), result = new Set();
+    for (let i = 0, n = parts.length; i < n; i++) {
+        let trimmed = parts[i].trim();
+        if (trimmed) {
+            result.add(trimmed);
+        }
+    }
+    return result;
+}
+function updateImportsWithRegex(code, specifiers, importRegex) {
+    let match = code.match(importRegex);
+    if (!match) {
+        return code;
+    }
+    let bracesMatch = match[1].match(BRACES_CONTENT_REGEX), existing = bracesMatch?.[1] ? parseSpecifiers(bracesMatch[1]) : new Set(), toAdd = [];
+    for (let spec of specifiers) {
+        if (!existing.has(spec)) {
+            toAdd.push(spec);
+        }
+    }
+    if (toAdd.length === 0) {
+        return code;
+    }
+    return code.replace(match[1], match[1].replace(BRACES_CONTENT_REGEX, `{ ${mergeAndSort(toAdd, existing)} }`));
+}
+const addImport = (code, module, specifiers) => {
+    if (specifiers.length === 0) {
+        return code;
+    }
+    let regex = buildImportRegex(module.replace(REGEX_ESCAPE_PATTERN, '\\$&'));
+    if (regex.test(code)) {
+        return updateImportsWithRegex(code, new Set(specifiers), regex);
+    }
+    let adding = `import { ${specifiers.sort().join(', ')} } from '${module}';\n`, first = code.indexOf('import ');
+    if (first === -1) {
+        return adding + code;
+    }
+    return code.substring(0, first) + adding + code.substring(first);
+};
+const applyReplacements = (code, replacements) => {
+    if (replacements.length === 0) {
+        return code;
+    }
+    replacements.sort((a, b) => a.start - b.start);
+    let parts = [], pos = 0;
+    for (let i = 0, n = replacements.length; i < n; i++) {
+        let r = replacements[i];
+        if (r.start > pos) {
+            parts.push(code.substring(pos, r.start));
+        }
+        parts.push(r.newText);
+        pos = r.end;
+    }
+    if (pos < code.length) {
+        parts.push(code.substring(pos));
+    }
+    return parts.join('');
+};
+const applyReplacementsReverse = (code, replacements) => {
+    if (replacements.length === 0) {
+        return code;
+    }
+    replacements.sort((a, b) => b.start - a.start);
+    let result = code;
+    for (let i = 0, n = replacements.length; i < n; i++) {
+        let r = replacements[i];
+        result = result.substring(0, r.start) + r.newText + result.substring(r.end);
+    }
+    return result;
+};
+const collectNodes = (sourceFile, predicate) => {
+    let matches = [];
+    function visit(node) {
+        let data = predicate(node);
+        if (data !== null) {
+            matches.push({
+                data,
+                end: node.end,
+                node,
+                start: node.getStart(sourceFile)
+            });
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return matches;
+};
+const mightNeedTransform = (code, check) => {
+    if (check.regex) {
+        return check.regex.test(code);
+    }
+    if (check.patterns) {
+        for (let i = 0, n = check.patterns.length; i < n; i++) {
+            if (code.indexOf(check.patterns[i]) !== -1) {
+                return true;
+            }
+        }
+    }
+    return false;
+};
+const uid = (prefix) => {
+    return (prefix ? prefix + '_' : '_') + uuid().replace(UUID_DASH_REGEX, '_');
+};
+const updateImports = (code, modification) => {
+    let { module, specifiers } = modification;
+    if (specifiers.size === 0) {
+        return code;
+    }
+    let escapedModule = module.replace(REGEX_ESCAPE_PATTERN, '\\$&'), importRegex = buildImportRegex(escapedModule);
+    return updateImportsWithRegex(code, specifiers, importRegex);
+};
+const visitAst = (sourceFile, callback, state, predicate) => {
+    function visit(node) {
+        if (!predicate || predicate(node)) {
+            callback(node, state);
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return state;
+};
+const visitAstWithDepth = (sourceFile, callback, state, depthTrigger) => {
+    let depthStack = [0];
+    function visit(node) {
+        let depth = depthStack[depthStack.length - 1], nextDepth = depthTrigger(node) ? depth + 1 : depth;
+        callback(node, depth, state);
+        depthStack.push(nextDepth);
+        ts.forEachChild(node, visit);
+        depthStack.pop();
+    }
+    visit(sourceFile);
+    return state;
+};
+export { addImport, applyReplacements, applyReplacementsReverse, collectNodes, mightNeedTransform, uid, updateImports, visitAst, visitAstWithDepth };

package/build/transformer/types.d.ts

@@ -0,0 +1,23 @@
+import ts from 'typescript';
+type ImportModification = {
+    module: string;
+    specifiers: Set<string>;
+};
+type NodeMatch<T> = {
+    data: T;
+    end: number;
+    node: ts.Node;
+    start: number;
+};
+type QuickCheckPattern = {
+    patterns?: string[];
+    regex?: RegExp;
+};
+type Replacement = {
+    end: number;
+    newText: string;
+    start: number;
+};
+type VisitorCallback<T> = (node: ts.Node, state: T) => void;
+type VisitorPredicate = (node: ts.Node) => boolean;
+export type { ImportModification, NodeMatch, QuickCheckPattern, Replacement, VisitorCallback, VisitorPredicate };

package/build/transformer/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -5,15 +5,20 @@
     "tsc-alias": "./bin/tsc-alias"
   },
   "dependencies": {
-    "@esportsplus/cli-passthrough": "^0.0.10",
+    "@esportsplus/cli-passthrough": "^0.0.12",
+    "@esportsplus/utilities": "^0.27.2",
     "tsc-alias": "^1.8.16",
-    "typescript": "^5.8.3"
+    "typescript": "^5.9.3"
   },
   "exports": {
     "./package.json": "./package.json",
     "./tsconfig.browser.json": "./tsconfig.browser.json",
     "./tsconfig.node.json": "./tsconfig.node.json",
     "./tsconfig.package.json": "./tsconfig.package.json",
+    "./transformer": {
+      "types": "./build/transformer/index.d.ts",
+      "default": "./build/transformer/index.js"
+    },
     ".": {
       "types": "./build/index.d.ts",
       "default": "./build/index.js"
@@ -22,9 +27,13 @@
   "main": "build/index.js",
   "name": "@esportsplus/typescript",
   "private": false,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/esportsplus/typescript"
+  },
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.9.2",
+  "version": "0.11.0",
   "scripts": {
     "build": "tsc && tsc-alias",
     "-": "-"

package/src/transformer/constants.ts

@@ -0,0 +1,8 @@
+const BRACES_CONTENT_REGEX = /\{([^}]*)\}/;
+
+const REGEX_ESCAPE_PATTERN = /[.*+?^${}()|[\]\\]/g;
+
+const UUID_DASH_REGEX = /-/g;
+
+
+export {  BRACES_CONTENT_REGEX, REGEX_ESCAPE_PATTERN, UUID_DASH_REGEX };

package/src/transformer/index.ts

@@ -0,0 +1,244 @@
+import { uuid } from '@esportsplus/utilities';
+import ts from 'typescript';
+import { BRACES_CONTENT_REGEX, REGEX_ESCAPE_PATTERN, UUID_DASH_REGEX } from './constants.js';
+import type { ImportModification, NodeMatch, QuickCheckPattern, Replacement, VisitorCallback, VisitorPredicate } from './types.js';
+
+
+function buildImportRegex(escapedModule: string): RegExp {
+    return new RegExp(`(import\\s*\\{[^}]*\\}\\s*from\\s*['"]${escapedModule}['"])`);
+}
+
+function mergeAndSort(a: string[], b: Set<string>): string {
+    let combined = new Array<string>(a.length + b.size),
+        idx = 0,
+        n = a.length;
+
+    for (let i = 0; i < n; i++) {
+        if (a[i]) {
+            combined[idx++] = a[i];
+        }
+    }
+
+    for (let item of b) {
+        if (item) {
+            combined[idx++] = item;
+        }
+    }
+
+    combined.length = idx;
+    combined.sort();
+
+    return combined.join(', ');
+}
+
+function parseSpecifiers(str: string): Set<string> {
+    let parts = str.split(','),
+        result = new Set<string>();
+
+    for (let i = 0, n = parts.length; i < n; i++) {
+        let trimmed = parts[i].trim();
+
+        if (trimmed) {
+            result.add(trimmed);
+        }
+    }
+
+    return result;
+}
+
+function updateImportsWithRegex(code: string, specifiers: Set<string>, importRegex: RegExp): string {
+    let match = code.match(importRegex);
+
+    if (!match) {
+        return code;
+    }
+
+    let bracesMatch = match[1].match(BRACES_CONTENT_REGEX),
+        existing = bracesMatch?.[1] ? parseSpecifiers(bracesMatch[1]) : new Set<string>(),
+        toAdd: string[] = [];
+
+    for (let spec of specifiers) {
+        if (!existing.has(spec)) {
+            toAdd.push(spec);
+        }
+    }
+
+    if (toAdd.length === 0) {
+        return code;
+    }
+
+    return code.replace(
+        match[1],
+        match[1].replace(BRACES_CONTENT_REGEX, `{ ${mergeAndSort(toAdd, existing)} }`)
+    );
+}
+
+
+const addImport = (code: string, module: string, specifiers: string[]): string => {
+    if (specifiers.length === 0) {
+        return code;
+    }
+
+    let regex = buildImportRegex( module.replace(REGEX_ESCAPE_PATTERN, '\\$&') );
+
+    if (regex.test(code)) {
+        return updateImportsWithRegex(code, new Set(specifiers), regex);
+    }
+
+    let adding = `import { ${specifiers.sort().join(', ')} } from '${module}';\n`,
+        first = code.indexOf('import ');
+
+    if (first === -1) {
+        return adding + code;
+    }
+
+    return code.substring(0, first) + adding + code.substring(first);
+};
+
+const applyReplacements = (code: string, replacements: Replacement[]): string => {
+    if (replacements.length === 0) {
+        return code;
+    }
+
+    replacements.sort((a, b) => a.start - b.start);
+
+    let parts: string[] = [],
+        pos = 0;
+
+    for (let i = 0, n = replacements.length; i < n; i++) {
+        let r = replacements[i];
+
+        if (r.start > pos) {
+            parts.push(code.substring(pos, r.start));
+        }
+
+        parts.push(r.newText);
+        pos = r.end;
+    }
+
+    if (pos < code.length) {
+        parts.push(code.substring(pos));
+    }
+
+    return parts.join('');
+};
+
+const applyReplacementsReverse = (code: string, replacements: Replacement[]): string => {
+    if (replacements.length === 0) {
+        return code;
+    }
+
+    replacements.sort((a, b) => b.start - a.start);
+
+    let result = code;
+
+    for (let i = 0, n = replacements.length; i < n; i++) {
+        let r = replacements[i];
+
+        result = result.substring(0, r.start) + r.newText + result.substring(r.end);
+    }
+
+    return result;
+};
+
+const collectNodes = <T>(sourceFile: ts.SourceFile, predicate: (node: ts.Node) => T | null): NodeMatch<T>[] => {
+    let matches: NodeMatch<T>[] = [];
+
+    function visit(node: ts.Node): void {
+        let data = predicate(node);
+
+        if (data !== null) {
+            matches.push({
+                data,
+                end: node.end,
+                node,
+                start: node.getStart(sourceFile)
+            });
+        }
+
+        ts.forEachChild(node, visit);
+    }
+
+    visit(sourceFile);
+
+    return matches;
+};
+
+const mightNeedTransform = (code: string, check: QuickCheckPattern): boolean => {
+    if (check.regex) {
+        return check.regex.test(code);
+    }
+
+    if (check.patterns) {
+        for (let i = 0, n = check.patterns.length; i < n; i++) {
+            if (code.indexOf(check.patterns[i]) !== -1) {
+                return true;
+            }
+        }
+    }
+
+    return false;
+};
+
+const uid = (prefix?: string): string => {
+    return (prefix ? prefix + '_' : '_') + uuid().replace(UUID_DASH_REGEX, '_');
+};
+
+const updateImports = (code: string, modification: ImportModification): string => {
+    let { module, specifiers } = modification;
+
+    if (specifiers.size === 0) {
+        return code;
+    }
+
+    let escapedModule = module.replace(REGEX_ESCAPE_PATTERN, '\\$&'),
+        importRegex = buildImportRegex(escapedModule);
+
+    return updateImportsWithRegex(code, specifiers, importRegex);
+};
+
+const visitAst = <T>(
+    sourceFile: ts.SourceFile,
+    callback: VisitorCallback<T>,
+    state: T,
+    predicate?: VisitorPredicate
+): T => {
+    function visit(node: ts.Node): void {
+        if (!predicate || predicate(node)) {
+            callback(node, state);
+        }
+
+        ts.forEachChild(node, visit);
+    }
+
+    visit(sourceFile);
+
+    return state;
+};
+
+const visitAstWithDepth = <T>(
+    sourceFile: ts.SourceFile,
+    callback: (node: ts.Node, depth: number, state: T) => void,
+    state: T,
+    depthTrigger: (node: ts.Node) => boolean
+): T => {
+    let depthStack: number[] = [0];
+
+    function visit(node: ts.Node): void {
+        let depth = depthStack[depthStack.length - 1],
+            nextDepth = depthTrigger(node) ? depth + 1 : depth;
+
+        callback(node, depth, state);
+        depthStack.push(nextDepth);
+        ts.forEachChild(node, visit);
+        depthStack.pop();
+    }
+
+    visit(sourceFile);
+
+    return state;
+};
+
+
+export { addImport, applyReplacements, applyReplacementsReverse, collectNodes, mightNeedTransform, uid, updateImports, visitAst, visitAstWithDepth };
+export type { ImportModification, NodeMatch, QuickCheckPattern, Replacement, VisitorCallback, VisitorPredicate };

package/src/transformer/types.ts

@@ -0,0 +1,38 @@
+import ts from 'typescript';
+
+
+type ImportModification = {
+    module: string;
+    specifiers: Set<string>;
+};
+
+type NodeMatch<T> = {
+    data: T;
+    end: number;
+    node: ts.Node;
+    start: number;
+};
+
+type QuickCheckPattern = {
+    patterns?: string[];
+    regex?: RegExp;
+};
+
+type Replacement = {
+    end: number;
+    newText: string;
+    start: number;
+};
+
+type VisitorCallback<T> = (node: ts.Node, state: T) => void;
+
+type VisitorPredicate = (node: ts.Node) => boolean;
+
+
+export type {
+    ImportModification,
+    NodeMatch,
+    QuickCheckPattern,
+    Replacement,
+    VisitorCallback, VisitorPredicate
+};