#!/usr/bin/env bash
# Default values
jobs=0 # 0 means auto-detect
output_dir="pdfs"
verbose=0
quiet=0
create_dirs=0
dry_run=0
skip_newer=0
show_progress=1
force=0
select_mode=0
use_cache=1 # Enable caching by default
cache_dir="${XDG_CACHE_HOME:-$HOME/.cache}/typst_compiler"
dependency_scan=1 # Enable dependency scanning by default
compile_log="typst_compile_errors.log"
move_log="typst_move_errors.log"
use_mtime=1 # Use modification time instead of hashes by default
declare -a exclude_patterns
# Show usage/help information
show_help() {
cat << EOF
Usage: $(basename "$0") [OPTIONS]
Compile Typst files and move generated PDFs to a designated directory.
Options:
-j, --jobs NUM Number of parallel jobs (default: auto-detect)
-o, --output-dir DIR Output directory name (default: pdfs)
-v, --verbose Increase verbosity
-q, --quiet Suppress most output
-c, --create-dirs Create output directories if they don't exist
-d, --dry-run Show what would be done without doing it
-s, --skip-newer Skip compilation if PDF is newer than source
-S, --select Interactive selection mode using skim
-f, --force Force compilation even if PDF exists
--no-progress Disable progress bar
--no-cache Disable compilation caching
--clear-cache Clear the cache before compiling
--no-deps Disable dependency scanning
--no-mtime Use file hashes instead of modification times
--cache-dir DIR Custom cache directory (default: ~/.cache/typst_compiler)
--compile-log FILE Custom location for compilation log (default: $compile_log)
--move-log FILE Custom location for move log (default: $move_log)
-e, --exclude PATTERN Exclude files matching pattern (can be used multiple times)
-h, --help Show this help message and exit
Examples:
$(basename "$0") -j 4 -o output -c
$(basename "$0") --verbose --skip-newer
$(basename "$0") -S # Select files to compile interactively
$(basename "$0") -e "**/test/**" -e "**/draft/**"
EOF
}
# Parse command line arguments
while [[ $# -gt 0 ]]; do
case $1 in
-j|--jobs)
jobs="$2"
shift 2
;;
-o|--output-dir)
output_dir="$2"
shift 2
;;
-v|--verbose)
verbose=1
shift
;;
-q|--quiet)
quiet=1
shift
;;
-c|--create-dirs)
create_dirs=1
shift
;;
-d|--dry-run)
dry_run=1
shift
;;
-s|--skip-newer)
skip_newer=1
shift
;;
-S|--select)
select_mode=1
shift
;;
-f|--force)
force=1
shift
;;
--no-progress)
show_progress=0
shift
;;
--no-cache)
use_cache=0
shift
;;
--clear-cache)
rm -rf "${cache_dir}"
shift
;;
--no-deps)
dependency_scan=0
shift
;;
--no-mtime)
use_mtime=0
shift
;;
--cache-dir)
cache_dir="$2"
shift 2
;;
--compile-log)
compile_log="$2"
shift 2
;;
--move-log)
move_log="$2"
shift 2
;;
-e|--exclude)
exclude_patterns+=("$2")
shift 2
;;
-h|--help)
show_help
exit 0
;;
*)
echo "Unknown option: $1"
show_help
exit 1
;;
esac
done
# Check for conflicting options
if [ "$verbose" -eq 1 ] && [ "$quiet" -eq 1 ]; then
echo "Error: Cannot use both --verbose and --quiet"
exit 1
fi
# Check if required tools are installed
check_tool() {
if ! command -v "$1" &> /dev/null; then
echo "$1 is not installed. Please install it first."
echo "On most systems: $2"
exit 1
fi
}
check_tool "fd" "cargo install fd-find or apt/brew install fd-find"
check_tool "rg" "cargo install ripgrep or apt/brew install ripgrep"
check_tool "parallel" "apt/brew install parallel"
# Check for skim and bat if select mode is enabled
if [ "$select_mode" -eq 1 ]; then
check_tool "sk" "cargo install skim or apt/brew install skim"
check_tool "bat" "cargo install bat or apt/brew install bat"
fi
# ANSI color codes
GREEN='\033[0;32m'
BLUE='\033[0;34m'
YELLOW='\033[0;33m'
RED='\033[0;31m'
CYAN='\033[0;36m'
PURPLE='\033[0;35m'
NC='\033[0m' # No Color
BOLD='\033[1m'
# Nerd font icons
ICON_SUCCESS="󰄬 "
ICON_ERROR="ó°…š "
ICON_WORKING="ó°„¾ "
ICON_COMPILE="󰈙 "
ICON_MOVE="ó°† "
ICON_COMPLETE="ó°„² "
ICON_SUMMARY="ó°‹½ "
ICON_INFO="ó°‹¼ "
ICON_DEBUG="󰃤 "
ICON_SELECT="ó°“¾ "
ICON_CACHE="ó°† "
ICON_FILE="󰈙 "
ICON_OPTIMIZE="ó°ª "
# Logging functions
log_debug() {
if [ "$verbose" -eq 1 ]; then
echo -e "${BLUE}$ICON_DEBUG${NC} $*"
fi
}
log_info() {
if [ "$quiet" -eq 0 ]; then
echo -e "${CYAN}$ICON_INFO${NC} $*"
fi
}
log_warning() {
if [ "$quiet" -eq 0 ]; then
echo -e "${YELLOW}âš ï¸ ${NC} $*"
fi
}
log_error() {
echo -e "${RED}${BOLD}$ICON_ERROR${NC} $*"
}
log_success() {
if [ "$quiet" -eq 0 ]; then
echo -e "${GREEN}${BOLD}$ICON_SUCCESS${NC} $*"
fi
}
# Create a directory for temporary files
temp_dir=$(mktemp -d)
compile_failures_dir="$temp_dir/compile_failures"
move_failures_dir="$temp_dir/move_failures"
progress_dir="$temp_dir/progress"
mkdir -p "$compile_failures_dir" "$move_failures_dir" "$progress_dir"
# Create cache directories if caching is enabled
if [ "$use_cache" -eq 1 ]; then
mkdir -p "${cache_dir}/info" "${cache_dir}/deps" "${cache_dir}/pdfs"
log_debug "Using cache directory: $cache_dir"
fi
# Create a lock file for progress updates and a flag for final progress
progress_lock="/tmp/typst_progress_lock"
final_progress_file="$temp_dir/final_progress"
touch "$final_progress_file"
# Initialize log files
> "$compile_log"
> "$move_log"
# Store current working directory
CWD=$(pwd)
log_info "Starting Typst compilation process..."
# Build exclude arguments for fd
fd_exclude_args=()
for pattern in "${exclude_patterns[@]}"; do
fd_exclude_args+=("-E" "$pattern")
done
# Create a list of files to process
typst_files_list="$temp_dir/typst_files.txt"
if [ "$select_mode" -eq 1 ]; then
log_info "${PURPLE}$ICON_SELECT${NC} Interactive selection mode enabled"
log_info "Use TAB to select multiple files, ENTER to confirm"
# Set up bat configuration for Typst syntax highlighting
bat_config="$temp_dir/bat_config"
mkdir -p "$bat_config/syntaxes"
export BAT_CONFIG_PATH="$bat_config"
# Use skim with bat for preview to select files
selected_files="$temp_dir/selected_files.txt"
# Find all eligible .typ files for selection
fd '\.typ$' --type f "${fd_exclude_args[@]}" . > "$typst_files_list.all"
# Check if we found any files
if [ ! -s "$typst_files_list.all" ]; then
log_error "No .typ files found matching your criteria."
rm -rf "$temp_dir"
exit 0
fi
# Prepare preview command for skim: use bat with custom syntax for .typ files
preview_cmd="bat --color=always --style=numbers --map-syntax='*.typ:Markdown' {} 2>/dev/null || cat {}"
# Use skim with bat preview to select files
cat "$typst_files_list.all" | sk --multi \
--preview "$preview_cmd" \
--preview-window "right:70%" \
--height "80%" \
--prompt "Select .typ files to compile: " \
--header "TAB: Select multiple files, ENTER: Confirm, CTRL-C: Cancel" \
--no-mouse > "$selected_files"
# Check if user selected any files
if [ ! -s "$selected_files" ]; then
log_error "No files selected. Exiting."
rm -rf "$temp_dir"
exit 0
fi
# Use the selected files instead of all discovered files
cp "$selected_files" "$typst_files_list"
total_selected=$(wc -l < "$typst_files_list")
total_available=$(wc -l < "$typst_files_list.all")
log_info "Selected ${BOLD}$total_selected${NC} out of ${BOLD}$total_available${NC} available files"
else
# Normal mode - process all files
fd '\.typ$' --type f "${fd_exclude_args[@]}" . > "$typst_files_list"
log_info "Found ${BOLD}$(wc -l < "$typst_files_list")${NC} Typst files to process"
fi
total_files=$(wc -l < "$typst_files_list")
# Store file metadata for faster access
declare -A file_mtime
declare -A file_target_path
# Function to extract Typst imports from a file
extract_dependencies() {
local file="$1"
# Match both import formats: #import "file.typ" and #include "file.typ"
# Also handle package imports: #import "@preview:0.1.0"
# Return full paths to local imports, skipping package imports
rg -U "#(import|include) \"(?!@)([^\"]+)\"" -r "$CWD/\$2" "$file" | \
while read -r dep; do
# Resolve relative paths correctly
if [[ "$dep" != /* ]]; then
# If not absolute path, make it relative to the file's directory
file_dir=$(dirname "$file")
dep="$file_dir/$dep"
fi
# Normalize path
dep=$(realpath --relative-to="$CWD" "$dep" 2>/dev/null || echo "$dep")
# Only output if the dependency exists and is a .typ file
if [[ "$dep" == *.typ ]] && [ -f "$dep" ]; then
echo "$dep"
fi
done | sort -u # Sort and remove duplicates
}
# Function to build dependency graph for all files
# Returns dependencies in reverse order (dependents -> dependencies)
build_dependency_graph() {
log_info "${ICON_CACHE} Building dependency graph..."
# Create a deps file for each Typst file and build dependency map
declare -A dependencies
declare -A dependency_of
while read -r file; do
file_id=$(echo "$file" | md5sum | cut -d' ' -f1)
deps_file="${cache_dir}/deps/${file_id}.deps"
# Skip if deps file is fresh and not forced
if [ "$force" -eq 0 ] && [ -f "$deps_file" ] && [ "$file" -ot "$deps_file" ]; then
log_debug "Using cached dependencies for $file"
# Load dependencies from cache
dependencies["$file"]=$(cat "$deps_file" | tr '\n' ' ')
# Update reverse dependency map
while read -r dep; do
dependency_of["$dep"]="${dependency_of["$dep"]} $file"
done < "$deps_file"
else
# Extract dependencies and save to deps file
extract_dependencies "$file" > "$deps_file"
# Store dependencies in map
dependencies["$file"]=$(cat "$deps_file" | tr '\n' ' ')
# Update reverse dependency map
while read -r dep; do
dependency_of["$dep"]="${dependency_of["$dep"]} $file"
done < "$deps_file"
log_debug "Updated dependencies for $file"
fi
done < "$typst_files_list"
# Store reverse dependencies back to cache
for dep in "${!dependency_of[@]}"; do
file_id=$(echo "$dep" | md5sum | cut -d' ' -f1)
echo "${dependency_of["$dep"]}" > "${cache_dir}/deps/${file_id}.rev"
done
# Create sorted compilation order based on dependencies
# Files with fewer dependencies (or no dependencies) come first
echo -n > "$temp_dir/compile_order.txt"
# First pass: count dependencies for each file
declare -A dep_counts
while read -r file; do
dep_count=$(echo "${dependencies["$file"]}" | wc -w)
dep_counts["$file"]=$dep_count
done < "$typst_files_list"
# Second pass: sort files by dependency count (ascending)
while read -r file; do
echo "${dep_counts["$file"]} $file"
done < "$typst_files_list" | sort -n | cut -d' ' -f2- > "$temp_dir/compile_order.txt"
log_debug "Created optimized compilation order"
}
# Function to get metadata of a typst file
get_file_metadata() {
local file="$1"
local output_dir="$2"
# Get file directory and basename
local file_dir=$(dirname "$file")
local filename=$(basename "$file")
local basename="${filename%.typ}"
# Check if output directory exists or should be created
local target_dir="$file_dir/$output_dir"
# Store target paths
file_target_path["$file"]="$target_dir/$basename.pdf"
# Store modification time
file_mtime["$file"]=$(stat -c %Y "$file" 2>/dev/null || stat -f %m "$file" 2>/dev/null)
}
# Function to initialize cache file for tracking modification times
init_mtime_cache() {
local mtime_cache="${cache_dir}/info/mtime_cache.txt"
# Create empty cache file if it doesn't exist
if [ ! -f "$mtime_cache" ]; then
touch "$mtime_cache"
fi
# Load existing mtimes from cache
declare -A cached_mtimes
while IFS=' ' read -r file time; do
if [ -n "$file" ] && [ -n "$time" ]; then
cached_mtimes["$file"]="$time"
fi
done < "$mtime_cache"
echo "$mtime_cache"
# Return the associative array of cached mtimes
for file in "${!cached_mtimes[@]}"; do
echo "$file ${cached_mtimes["$file"]}"
done
}
# Function to save the modification time cache
save_mtime_cache() {
local mtime_cache="${cache_dir}/info/mtime_cache.txt"
> "$mtime_cache"
# Save current file mtimes to cache
for file in "${!file_mtime[@]}"; do
echo "$file ${file_mtime["$file"]}" >> "$mtime_cache"
done
}
# Function to determine if a file or its dependencies have changed
needs_compilation() {
local file="$1"
local target_pdf="${file_target_path["$file"]}"
local file_dir=$(dirname "$file")
local basename=$(basename "${file%.typ}")
# If force is enabled, always compile
if [ "$force" -eq 1 ]; then
log_debug "Force compilation of $file"
return 0
fi
# Check if the target path has been created
if [ -z "$target_pdf" ]; then
# Target not set, let's set it now
get_file_metadata "$file" "$output_dir"
target_pdf="${file_target_path["$file"]}"
fi
# Check if target directory exists
target_dir=$(dirname "$target_pdf")
if [ ! -d "$target_dir" ]; then
if [ "$create_dirs" -eq 1 ]; then
# Will create directory later
log_debug "Will create directory $target_dir for $file"
else
# Skip if target directory doesn't exist and --create-dirs not specified
log_debug "Skipping $file (no $output_dir directory)"
return 1
fi
fi
# Check if target PDF exists
if [ ! -f "$target_pdf" ]; then
log_debug "Target PDF doesn't exist for $file"
return 0
fi
# Check if PDF is newer than source and --skip-newer is specified
if [ "$skip_newer" -eq 1 ]; then
if [ -n "${file_mtime["$file"]}" ] && [ -f "$target_pdf" ]; then
target_mtime=$(stat -c %Y "$target_pdf" 2>/dev/null || stat -f %m "$target_pdf" 2>/dev/null)
if [ "${file_mtime["$file"]}" -lt "$target_mtime" ]; then
log_debug "Skipping $file (PDF is newer)"
return 1
fi
fi
fi
# If not using mtime, do hash-based checks
if [ "$use_mtime" -eq 0 ]; then
# Use hash-based change detection
file_hash=$(echo "$file" | md5sum | cut -d' ' -f1)
hash_file="${cache_dir}/info/${file_hash}.sha256"
if [ ! -f "$hash_file" ]; then
log_debug "No previous hash for $file"
return 0
fi
current_hash=$(sha256sum "$file" | cut -d' ' -f1)
stored_hash=$(cat "$hash_file")
if [ "$current_hash" != "$stored_hash" ]; then
log_debug "File $file has changed since last compilation (hash)"
return 0
fi
else
# Use mtime-based change detection
if [ -n "$cached_mtimes" ]; then
read_cached_mtimes=$(init_mtime_cache)
while IFS=' ' read -r cached_file cached_time; do
if [ "$cached_file" = "$file" ]; then
current_mtime="${file_mtime["$file"]}"
if [ "$current_mtime" != "$cached_time" ]; then
log_debug "File $file has changed since last compilation (mtime)"
return 0
fi
break
fi
done <<< "$read_cached_mtimes"
fi
fi
# Check if any dependencies have changed if dependency scanning is enabled
if [ "$dependency_scan" -eq 1 ]; then
file_id=$(echo "$file" | md5sum | cut -d' ' -f1)
deps_file="${cache_dir}/deps/${file_id}.deps"
if [ -f "$deps_file" ]; then
while read -r dep; do
# Recursively check if dependency has changed
if needs_compilation "$dep"; then
log_debug "Dependency $dep of $file needs compilation"
return 0
fi
done < "$deps_file"
fi
fi
log_debug "File $file and its dependencies haven't changed"
return 1 # No compilation needed
}
# Function to update file metadata after compilation
update_file_metadata() {
local file="$1"
# Update modification time
file_mtime["$file"]=$(stat -c %Y "$file" 2>/dev/null || stat -f %m "$file" 2>/dev/null)
# Update hash if not using mtime
if [ "$use_mtime" -eq 0 ]; then
local file_hash=$(echo "$file" | md5sum | cut -d' ' -f1)
local hash_file="${cache_dir}/info/${file_hash}.sha256"
sha256sum "$file" | cut -d' ' -f1 > "$hash_file"
log_debug "Updated hash for $file"
fi
}
# Function to cache compiled PDF
cache_pdf() {
local src_file="$1"
local pdf_file="$2"
if [ ! -f "$pdf_file" ]; then
log_debug "No PDF file to cache: $pdf_file"
return 1
fi
local file_hash=$(echo "$src_file" | md5sum | cut -d' ' -f1)
local cached_pdf="${cache_dir}/pdfs/${file_hash}.pdf"
# Copy PDF to cache
cp "$pdf_file" "$cached_pdf"
log_debug "Cached PDF for $src_file"
return 0
}
# Function to retrieve cached PDF
get_cached_pdf() {
local src_file="$1"
local target_file="$2"
local file_hash=$(echo "$src_file" | md5sum | cut -d' ' -f1)
local cached_pdf="${cache_dir}/pdfs/${file_hash}.pdf"
if [ ! -f "$cached_pdf" ]; then
log_debug "No cached PDF for $src_file"
return 1
fi
# Create target directory if needed
target_dir=$(dirname "$target_file")
if [ ! -d "$target_dir" ] && [ "$create_dirs" -eq 1 ]; then
mkdir -p "$target_dir"
fi
# Copy cached PDF to target location
cp "$cached_pdf" "$target_file"
log_debug "Retrieved cached PDF for $src_file"
return 0
}
# Function to update progress bar during processing
update_progress_during() {
# If progress is disabled, do nothing
if [ "$show_progress" -eq 0 ]; then
return 0
fi
(
# Try to acquire lock, but don't wait if busy
flock -n 200 || return 0
completed=$(find "$progress_dir" -type f | wc -l)
percent=$((completed * 100 / compilation_count))
bar_length=50
filled_length=$((bar_length * completed / compilation_count))
# Create the progress bar
bar=""
for ((i=0; i<bar_length; i++)); do
if [ $i -lt $filled_length ]; then
bar="${bar}â–ˆ"
else
bar="${bar}â–‘"
fi
done
# Calculate success and failure counts
success=$((completed - $(find "$compile_failures_dir" "$move_failures_dir" -type f | wc -l)))
compile_fails=$(find "$compile_failures_dir" -type f | wc -l)
move_fails=$(find "$move_failures_dir" -type f | wc -l)
# Clear the previous line and print the updated progress
echo -ne "\r\033[K"
echo -ne "${PURPLE}$ICON_WORKING Progress: ${GREEN}$bar ${BOLD}${percent}%${NC} "
echo -ne "[${GREEN}${success}✓${NC}|${RED}${compile_fails}✗${NC}|${YELLOW}${move_fails}!${NC}] "
echo -ne "${BLUE}($completed/$compilation_count)${NC}"
# If all files are processed, print the completion message ONLY ONCE
if [ $completed -eq $compilation_count ] && [ ! -e "$final_progress_file.done" ]; then
touch "$final_progress_file.done"
echo -e "\n${GREEN}${BOLD}$ICON_COMPLETE All files processed!${NC}"
fi
) 200>"$progress_lock"
}
# Function to show final progress (called only once at the end)
show_final_progress() {
# If progress is disabled, do nothing
if [ "$show_progress" -eq 0 ]; then
return 0
fi
(
flock -w 1 200
# Only proceed if the final progress hasn't been shown yet
if [ -e "$final_progress_file.done" ]; then
return 0
fi
completed=$(find "$progress_dir" -type f | wc -l)
percent=$((completed * 100 / compilation_count))
bar_length=50
filled_length=$((bar_length * completed / compilation_count))
# Create the progress bar
bar=""
for ((i=0; i<bar_length; i++)); do
if [ $i -lt $filled_length ]; then
bar="${bar}â–ˆ"
else
bar="${bar}â–‘"
fi
done
# Calculate success and failure counts
success=$((completed - $(find "$compile_failures_dir" "$move_failures_dir" -type f | wc -l)))
compile_fails=$(find "$compile_failures_dir" -type f | wc -l)
move_fails=$(find "$move_failures_dir" -type f | wc -l)
# Clear the previous line and print the updated progress
echo -ne "\r\033[K"
echo -ne "${PURPLE}$ICON_WORKING Progress: ${GREEN}$bar ${BOLD}${percent}%${NC} "
echo -ne "[${GREEN}${success}✓${NC}|${RED}${compile_fails}✗${NC}|${YELLOW}${move_fails}!${NC}] "
echo -ne "${BLUE}($completed/$compilation_count)${NC}"
# Mark final progress as shown
touch "$final_progress_file.done"
# If all files are processed, print the completion message
if [ $completed -eq $compilation_count ]; then
echo -e "\n${GREEN}${BOLD}$ICON_COMPLETE All files processed!${NC}"
fi
) 200>"$progress_lock"
}
# Function to process a single .typ file
process_file() {
typfile="$1"
file_id=$(echo "$typfile" | md5sum | cut -d' ' -f1)
# Get target path and other metadata
target_pdf="${file_target_path["$typfile"]}"
target_dir=$(dirname "$target_pdf")
basename=$(basename "${typfile%.typ}")
# Create a temporary file for capturing compiler output
temp_output="$temp_dir/output_${file_id}.log"
# Add a header to the log before compilation
{
echo -e "\n===== COMPILING: $typfile ====="
echo "$(date)"
} > "$temp_output.header"
# In dry run mode, just log what would be done
if [ "$dry_run" -eq 1 ]; then
log_debug "[DRY RUN] Would compile: $typfile"
log_debug "[DRY RUN] Would move to: $target_pdf"
touch "$progress_dir/$file_id"
update_progress_during
return 0
fi
# Ensure output directory exists if --create-dirs is enabled
if [ "$create_dirs" -eq 1 ] && [ ! -d "$target_dir" ]; then
mkdir -p "$target_dir"
log_debug "Created directory: $target_dir"
fi
# Try to use cached PDF if available and file hasn't changed
if [ "$use_cache" -eq 1 ]; then
if get_cached_pdf "$typfile" "$target_pdf"; then
log_debug "Used cached PDF for $typfile"
touch "$progress_dir/$file_id"
update_progress_during
return 0
fi
fi
# Compile the .typ file using typst with --root flag and capture all output
typdir=$(dirname "$typfile")
if ! typst compile --root "$CWD" "$typfile" > "$temp_output.stdout" 2> "$temp_output.stderr"; then
# Store the failure
echo "$typfile" > "$compile_failures_dir/$file_id"
log_debug "Compilation failed for $typfile"
# Combine stdout and stderr
cat "$temp_output.stdout" "$temp_output.stderr" > "$temp_output.combined"
# Filter the output to only include error messages using ripgrep
rg "error:" -A 20 "$temp_output.combined" > "$temp_output.errors" || true
# Lock the log file to avoid concurrent writes corrupting it
(
flock -w 1 201
cat "$temp_output.header" "$temp_output.errors" >> "$compile_log"
echo -e "\n" >> "$compile_log"
) 201>"$compile_log.lock"
else
# Check if the output PDF exists
temp_pdf="$typdir/$basename.pdf"
if [ -f "$temp_pdf" ]; then
# Cache the PDF if caching is enabled
if [ "$use_cache" -eq 1 ]; then
cache_pdf "$typfile" "$temp_pdf"
# Update file metadata
update_file_metadata "$typfile"
fi
# Try to move the output PDF to the output directory
move_header="$temp_dir/move_${file_id}.header"
{
echo -e "\n===== MOVING: $typfile ====="
echo "$(date)"
} > "$move_header"
if ! mv "$temp_pdf" "$target_dir/" 2> "$temp_output.move_err"; then
echo "$typfile -> $target_pdf" > "$move_failures_dir/$file_id"
log_debug "Failed to move $basename.pdf to $target_dir/"
# Lock the log file to avoid concurrent writes corrupting it
(
flock -w 1 202
cat "$move_header" "$temp_output.move_err" >> "$move_log"
echo "Failed to move $temp_pdf to $target_dir/" >> "$move_log"
) 202>"$move_log.lock"
else
log_debug "Moved $basename.pdf to $target_dir/"
fi
else
# This is a fallback check in case typst doesn't return error code
echo "$typfile" > "$compile_failures_dir/$file_id"
log_debug "Compilation completed without errors but no PDF was generated for $typfile"
# Lock the log file to avoid concurrent writes corrupting it
(
flock -w 1 201
echo "Compilation completed without errors but no PDF was generated" >> "$compile_log"
) 201>"$compile_log.lock"
fi
fi
# Mark this file as processed (for progress tracking)
touch "$progress_dir/$file_id"
# Update the progress bar
update_progress_during
}
export -f process_file
export -f update_progress_during
export -f show_final_progress
export -f log_debug
export -f log_info
export -f log_warning
export -f log_error
export -f log_success
export -f update_file_metadata
export -f cache_pdf
export -f get_cached_pdf
export CWD
export temp_dir
export compile_failures_dir
export move_failures_dir
export progress_dir
export final_progress_file
export progress_lock
export compile_log
export move_log
export cache_dir
export GREEN BLUE YELLOW RED CYAN PURPLE NC BOLD
export ICON_SUCCESS ICON_ERROR ICON_WORKING ICON_COMPILE ICON_MOVE ICON_COMPLETE ICON_SUMMARY ICON_INFO ICON_DEBUG ICON_CACHE ICON_FILE
export verbose
export quiet
export output_dir
export create_dirs
export dry_run
export skip_newer
export show_progress
export force
export use_cache
export dependency_scan
export use_mtime
# Determine the number of CPU cores and use that many parallel jobs (if not specified)
if [ "$jobs" -eq 0 ]; then
jobs=$(nproc 2>/dev/null || sysctl -n hw.ncpu 2>/dev/null || echo 4)
fi
log_info "Using ${BOLD}$jobs${NC} parallel jobs for compilation"
# Process file collection and get ready for compilation
if [ "$total_files" -gt 0 ]; then
# Get file metadata for all files
log_info "${ICON_FILE} Collecting file information..."
while read -r file; do
get_file_metadata "$file" "$output_dir"
done < "$typst_files_list"
# Build dependency graph if dependency scanning is enabled
if [ "$dependency_scan" -eq 1 ]; then
build_dependency_graph
# Use optimized compilation order
cp "$temp_dir/compile_order.txt" "$typst_files_list"
log_info "${ICON_OPTIMIZE} Optimized compilation order based on dependencies"
fi
# Filter files that need compilation
log_info "${ICON_FILE} Checking for changes..."
files_to_compile="$temp_dir/files_to_compile.txt"
> "$files_to_compile"
while read -r file; do
if needs_compilation "$file"; then
echo "$file" >> "$files_to_compile"
else
# Mark as processed but not compiled
file_id=$(echo "$file" | md5sum | cut -d' ' -f1)
touch "$progress_dir/$file_id"
fi
done < "$typst_files_list"
# Count files that need compilation
compilation_count=$(wc -l < "$files_to_compile")
skipped_count=$((total_files - compilation_count))
# Export compilation count for progress tracking
export compilation_count
if [ "$compilation_count" -eq 0 ]; then
log_success "All files are up to date, nothing to compile."
rm -rf "$temp_dir"
rm -f "$progress_lock" "$compile_log.lock" "$move_log.lock"
if [ "$use_cache" -eq 1 ] && [ "$use_mtime" -eq 1 ]; then
save_mtime_cache
fi
exit 0
fi
log_info "Need to compile ${BOLD}$compilation_count${NC} files (skipping $skipped_count unchanged files)"
# Initialize progress bar if showing progress
if [ "$show_progress" -eq 1 ]; then
update_progress_during
fi
# Process files in parallel with --will-cite to suppress citation notice
cat "$files_to_compile" | parallel --will-cite --jobs "$jobs" process_file
# Wait a moment for any remaining progress updates to complete
sleep 0.5
# Save updated mtime cache
if [ "$use_cache" -eq 1 ] && [ "$use_mtime" -eq 1 ]; then
save_mtime_cache
fi
# Show the final progress exactly once if showing progress
if [ "$show_progress" -eq 1 ]; then
show_final_progress
fi
# Print summary of failures
if [ "$quiet" -eq 0 ]; then
echo -e "\n${BOLD}${PURPLE}$ICON_SUMMARY Processing Summary${NC}"
fi
# Collect all failure files
compile_failures=$(find "$compile_failures_dir" -type f | wc -l)
move_failures=$(find "$move_failures_dir" -type f | wc -l)
if [ "$compile_failures" -eq 0 ] && [ "$move_failures" -eq 0 ]; then
log_success "All files processed successfully."
else
if [ "$compile_failures" -gt 0 ]; then
echo -e "\n${RED}${BOLD}$ICON_ERROR Compilation failures:${NC}"
find "$compile_failures_dir" -type f -exec cat {} \; | sort | while read -r failure; do
echo -e "${RED}- $failure${NC}"
done
echo -e "${BLUE}See $compile_log for detailed error messages.${NC}"
fi
if [ "$move_failures" -gt 0 ]; then
echo -e "\n${YELLOW}${BOLD}$ICON_ERROR Move failures:${NC}"
find "$move_failures_dir" -type f -exec cat {} \; | sort | while read -r failure; do
echo -e "${YELLOW}- $failure${NC}"
done
echo -e "${BLUE}See $move_log for detailed error messages.${NC}"
fi
fi
# Cache usage statistics (if enabled and not in quiet mode)
if [ "$use_cache" -eq 1 ] && [ "$quiet" -eq 0 ]; then
cache_files=$(find "${cache_dir}/pdfs" -type f | wc -l)
cache_size=$(du -sh "${cache_dir}" 2>/dev/null | cut -f1)
echo -e "\n${CYAN}${ICON_CACHE} Cache statistics:${NC}"
echo -e " - Cached files: ${BOLD}$cache_files${NC}"
echo -e " - Cache size: ${BOLD}$cache_size${NC}"
echo -e " - Cache location: ${BOLD}$cache_dir${NC}"
echo -e " - Change detection: ${BOLD}$([ "$use_mtime" -eq 1 ] && echo "Modification time" || echo "File hash")${NC}"
fi
else
log_warning "No .typ files found to process."
fi
# Clean up temporary directory and lock files
rm -rf "$temp_dir"
rm -f "$progress_lock" "$compile_log.lock" "$move_log.lock"
log_success "Processing complete."