Waffle1412 / Typst Compiler Utility

#!/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."