repository·main·Indexed 12 days ago
https://github.com/microsoft/typescript-goA native implementation of the TypeScript language service providing high-performance IDE features such as completions, diagnostics, and go-to-definition. Includes the tsgo command as a drop-in replacement for tsc, a native preview extension for VS Code, and internal Go-based filesystem watching via fswatch.
Glob patterns are transformed from a raw Spec into a Pattern via the COMPILE_PATTERN process.
basePath into absolute path components.., *, or ?, the algorithm treats it as an implicit glob by appending ** and * to the components.** becomes a DoubleAsterisk component.* or ? become Literal components.* or ? become Wildcard components, which are further parsed into SegLiteral, SegStar, or SegQuestion segments.Note: If the last element of the normalized components is ** and the usage mode is not Exclude, compilation will fail.
TypeScript support and servicing depend on how the project is being consumed:
The glob matching algorithm includes a default exclusion rule for .min.js files to prevent them from being matched by default in certain scenarios.
Rules for exclusion:
.min.js suffix (case-sensitivity depends on the pattern configuration)..min.js or .min. suffix within its literal segments.If the pattern is not in Files mode, or if the file/pattern does not meet the suffix criteria, the exclusion does not apply.
The internal formatting process follows this lifecycle:
Format* methods to configure a FormatSpan, which defines the specific range of the SourceFile to be formatted.processNode is called on children to determine and pass down indentation levels.processPair, which compares the current node with the previous node. This method mutates the formatting context and uses createRulesMap to fetch a set of rules.rules.ts) that reference node pairs or token ranges to determine which actions to apply.The glob matching logic follows a formal specification to ensure consistent file-path matching. Key concepts include:
/-separated absolute file path (e.g., /project/src/index.ts)./ delimiters. The root component is an empty string "".src/**/*.ts).Files: Matches complete file paths.Directories: Matches directory prefixes for traversal pruning.Exclude: Matches paths to be excluded.Literal: No * or ? characters.Wildcard: Contains * or ? characters.DoubleAsterisk: The exact string **.SegLiteral: An exact literal substring.SegStar: Matches zero or more characters excluding /.SegQuestion: Matches exactly one character excluding /.While fswatch.Default() automatically selects the best watcher for the current OS, you can explicitly request a specific backend. All watchers are available on every platform, but they may not be supported by the underlying kernel.
To check if a watcher is supported at runtime, use fswatch.Available(). If you attempt to use an unsupported watcher, WatchDirectory will return fswatch.ErrUnavailable.
Supported watchers by OS:
fanotify (default, kernel ≥ 5.13), inotifyFSEvents (default), kqueueReadDirectoryChangesWkqueue// Example of using a specific watcher with options
sub, err := fswatch.Inotify().WatchDirectory(dir, callback, fswatch.WithRecursive())TypeScript formatting requires two primary components: a SourceFile representing the code and a formatting context containing user settings (such as tab size and newline character).
The output of the formatting process is a collection of TextChange objects. Each TextChange object contains the new string content and the specific text it is intended to replace.
The matching algorithm applies specific constraints during traversal and wildcard evaluation:
. (e.g., .gitignore), it is considered a hidden path. If a DoubleAsterisk or a Wildcard (starting with * or ?) attempts to match a hidden path, the match will fail (unless in Exclude mode).node_modules, bower_components, or jspm_packages (case-insensitive) are treated as package folders. If a DoubleAsterisk or a Wildcard component encounters a package folder, the match is rejected (unless in Exclude mode).**): This component allows for matching across multiple directory levels. It attempts to skip segments to find a valid match for the subsequent pattern components.When consuming events from fswatch, be aware of the following behaviors:
filepath.EvalSymlinks to ensure consistency.When implementing or using the glob matching algorithm, be aware of these core invariants:
** will cause COMPILE_PATTERN to return failure.true and all other patterns return false.MATCH_SEGMENTS is guaranteed to be $O(n imes m)$, where $n$ is string length and $m$ is segment count.** does not descend into hidden paths or package folders.*) or question mark (?) will not match hidden path components.To monitor a directory for changes, use fswatch.Default().WatchDirectory(path, callback). The callback receives a slice of fswatch.Event objects and an error. Each event contains a Kind and an absolute Path.
Note that the callback runs on a library goroutine and is serialized for each watch, meaning the same watch's callback will never run concurrently with itself. Because backends report canonical paths, you should resolve symlinks using filepath.EvalSymlinks before subscribing to ensure the path matches your expectations.
package main
import (
"fmt"
"log"
"os"
"os/signal"
"github.com/microsoft/typescript-go/internal/fswatch"
)
func main() {
dir, _ := os.Getwd()
sub, err := fswatch.Default().WatchDirectory(dir, func(events []fswatch.Event, err error) {
if err != nil {
log.Println("watch error:", err)
return
}
for _, e := range events {
fmt.Printf("%s %s\n", e.Kind, e.Path)
}
})
if err != nil {
log.Fatal(err)
}
defer sub.Close()
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
<-c
}