`#!/usr/bin/env node ` #log = require 'why-is-node-running' metadata = require './package.json' child_process = require 'child_process' EventEmitter = require 'events' fs = require 'fs/promises' fsNormal = require 'fs' os = require 'os' path = require 'path' defaultSettings = ## Whether to force conversion, even if SVG file is older than target. force: false ## Whether to run jobs with relative paths, or resolve to absolute paths. ## Absolute paths support changing directories between jobs, but relative ## paths are shorter and might bypass some limitations. relative: false ## Directories to output all or some files. outputDir: null ## default: same directory as input outputDirExt: ## by extension; default is to use outputDir '.pdf': null '.png': null ## Delete output files instead of creating them, like `make clean`. clean: false ## Path to inkscape. Default searches PATH. inkscape: 'inkscape' ## Maximum number of Inkscapes to run in parallel. ## Default = number of physical CPU cores (assuming hyperthreading). jobs: try Math.max 1, os.cpus().length // 2 catch 1 ## If an Inkscape process sits idle for this many milliseconds, close it. ## Default = 1 minute. Set to null to disable. idle: 60000 ## If an Inkscape fails to start shell for this many milliseconds, fail. ## Default = 1 minute. Set to null to disable. startTimeout: 60000 ## If an Inkscape fails to close for this many milliseconds, kill it. ## Default = 1 second. Set to null to disable. quitTimeout: 1000 ## Wait for an input file to stop changing for this many milliseconds ## before watch triggers conversion. Default = 1 second. settle: 1000 ## Whether to sanitize PDF output by blanking out /CreationDate. sanitize: true ## Buffer size for sanitization. bufferSize: 16*1024 invalidFilename = (filename) => /^\s|\s$|;/.test filename class InkscapeError extends Error constructor: (message) -> super message @name = 'InkscapeError' class Inkscape constructor: (@settings = defaultSettings) -> open: (initialUnref) -> ## Start Inkscape process. Returns a Promise. ## `initialUnref` specifies whether to unref the Inkscape process ## before it finishes starting; set true for secondary Inkscape processes. new Promise (@resolve, @reject) => @stdout = @stderr = '' @dead = @ready = @started = false #console.log (new Date), 'start' @process = child_process.spawn @settings.inkscape, ['--shell'] ## Node can close independent of pipes; rely on @process.ref/unref for handle in [@process.stdin, @process.stdout, @process.stderr] handle.unref() ## Don't wait for a new Inkscape to start, unless requested. @process.unref() if initialUnref ## Check for failure to start. @timeout = setTimeout => @reject new InkscapeError "'#{@settings.inkscape} --shell' produced no '> ' prompt after #{@settings.startTimeout / 1000} seconds" , @settings.startTimeout if @settings.startTimeout @timeout.unref() @process.stderr.on 'data', (buf) => @stderr += buf @process.stdout.on 'data', (buf) => @stdout += buf if @stdout == '> ' or @stdout.endsWith '\n> ' #console.log (new Date), 'ready' unless @started ## Inkscape just started up, or finished a job. Allow Node to exit. ## In the first case, don't call unref() a second time. @process.unref() if @job? or not initialUnref @ready = @started = true clearTimeout @timeout if @timeout? if @settings.idle? @timeout = setTimeout (=> @close()), @settings.idle @timeout.unref() stdout = @stdout .replace /> $/, '' # next prompt .replace /^([^\n]*)(\n|$)/, (match, firstLine) => ## Remove first line of output if it includes the job input, ## possibly with some complex readline output after first \r. if @cmd?.startsWith firstLine.replace /\r[^]*$/, '' '' else match stderr = @stderr @stdout = @stderr = '' @resolve? {...@job, stdout, stderr} @resolve = @reject = @job = @cmd = null @process.on 'error', (error) => @closed() if @reject? error[key] = value for key, value of @job if @job? @reject error else throw new InkscapeError "Uncaught Inkscape error: #{error.message}" @process.on 'exit', (status, signal) => return if @dead # ignore exit event after error event @closed() if status or signal or not @started message = "'#{@settings.inkscape} --shell' exited " + if status "with status #{status}" else if signal "with signal #{signal}" else "without status or signal before '> ' prompt" if @reject? error = new InkscapeError message error[key] = value for key, value of @job if @job? error.status = status error.signal = signal @reject error @resolve = @reject = @job = @cmd = null else throw new InkscapeError "Uncaught Inkscape crash: #{message}" else @resolve?( stdout: @stdout stderr: @stderr ) @resolve = @reject = null close: -> ## Gently close Inkscape process, or if it doesn't respond, kill it. ## Returns a Promise. new Promise (@resolve, @reject) => #@process.stdin.write 'quit\n' @process.stdin.end() @process.unref() if @settings.quitTimeout? @timeout = setTimeout => @process.kill() unless @dead , @settings.quitTimeout @timeout.unref() closed: -> ## Inkscape process has closed; turn everything off. @dead = true @ready = false clearTimeout @timeout if @timeout? run: (job) -> ## Send job to Inkscape. Returns a Promise. ## Job can be a string to send to the shell, ## or an object with a `job` string property, ## or an object with `input` and `output` properties for conversion. unless @ready and not @job throw new InkscapeError 'Attempt to run Inkscape job before ready' @ready = false @process.ref() clearTimeout @timeout if @timeout? job = {job} if typeof job == 'string' @job = job if job?.job? @cmd = job.job.replace /\n+$/, '' else if job?.input? and job.output? @cmd = [ "file-open:#{@job.inputAbs ? @job.input}" "export-filename:#{job.outputAbs ? @job.output}" 'export-overwrite' 'export-do' ].join ';' #console.log @cmd else throw new InkscapeError "Invalid Inkscape job: #{@job}" @cmd += '\n' new Promise (@resolve, @reject) => @process.stdin.write @cmd class SVGProcessor extends EventEmitter constructor: (@settings = defaultSettings) -> super() @inkscapes = [] @queue = [] @spawning = false @jobs = 0 convertGlob: (input, formats) -> ## Convert directory or glob pattern into specified format(s). ## Use input/converted/error events to consume results. @jobs++ # treat glob as an additional job, to avoid premature exit {type, input} = await @parseGlob input if type == 'file' @jobs-- # will be immediately incremented by convert job return @convertTo input, formats @makeGlob input, nodir: true .on 'match', (file) => @convertTo file, formats .on 'end', (matches) => unless matches.length console.log "! No files found matching '#{input}'" @jobs-- # finished glob job @update() if @waiting # resolve wait() in case this was last job escapeGlob: (input) -> input.replace /[\*\+\?\!\|\@\(\)\[\]\{\}]/g, '\\$&' parseGlob: (input) -> try stat = await fs.stat input if stat?.isFile() type = 'file' else if stat?.isDirectory() # directory treated as /*.svg glob type = 'dir' ## glob requires forward slashes for directory separators. if os.platform() == 'win32' input = input.replace /\\/g, '/' ## Escape all glob syntax, as this is a real path. input = @escapeGlob input input += '/*.svg' else # path doesn't exist, so treat as glob type = 'glob' ## Support backslash in Windows path as long as not meaningful escape. if os.platform() == 'win32' input = input.replace /\\($|[^\*\+\?\!\|\@\(\)\[\]\{\}])/g, '/$1' {type, input} makeGlob: (input, options = {}) -> {Glob} = require 'glob' new Glob input, options .on 'error', (error) => @emit 'error', error convertTo: (input, format, emit = true) -> ## Convert input filename to output file format(s), e.g.: ## 'pdf', 'png', '.pdf', '.png', or ['pdf', 'png']. ## Generates output filename(s) using `settings.outputDir*` ## and then calls `convert`. ## Returns a Promise or Array of Promises (when `format` is an Array). ## Each Promise has additional `output` property with generated filename. @emit 'input', input if emit if Array.isArray format @update() unless format.length # job immediately finished if no formats return (@convertTo input, f, false for f in format) ## Single format case. Generate output filename. format = ".#{format}" unless format.startsWith '.' parsed = path.parse input delete parsed.base # use ext instead if parsed.ext != format parsed.ext = format else parsed.ext += format if @settings.outputDirExt[format]? dir = @settings.outputDirExt[format] else if @settings.outputDir? dir = @settings.outputDir if dir? ## Try to make output directory, synchronously to avoid multiple ## async threads trying to make the same directory at once. try fsNormal.mkdirSync dir, recursive: true catch error console.log "! Failed to make directory '#{dir}': #{error.message}" parsed.dir = dir output = path.format parsed ## Call convert. promise = @convert input, output promise.output = output promise convert: (input, output) -> ## Convert input filename to output filename, and then sanitize, ## unless output is newer than input or forced. Returns a Promise. unless @settings.relative inputAbs = path.resolve input outputAbs = path.resolve output @jobs++ if @settings.clean cleaned = {input, output, inputAbs, outputAbs} return fs.unlink outputAbs .then => @emit 'cleaned', cleaned cleaned .catch (error) => if error.code == 'ENOENT' cleaned.skip = true @emit 'cleaned', cleaned else @emit 'error', error .finally => @jobs-- @update() new Promise (resolve, reject) => for filename in [inputAbs ? input, outputAbs ? output] if invalidFilename filename @jobs-- reject new InkscapeError "Inkscape shell does not support filenames with semicolons or leading/trailing spaces: #{filename}" @update() if @waiting # resolve wait() in case this was last job return ## Compare input and output modification times, unless forced. unless @settings.force try outputStat = await fs.stat output inputStat = await fs.stat input unless inputStat? and outputStat? and inputStat.mtime < outputStat.mtime @queue.push {job: {input, output, inputAbs, outputAbs}, resolve, reject} @update() else @jobs-- resolve {input, output, inputAbs, outputAbs, skip: true} @update() if @waiting # resolve wait() in case last job is skipped undefined .then (result) => @emit 'converted', result result .catch (error) => @emit 'error', error # throws if no error listeners run: (job) -> ## Queue job for Inkscape to run. Returns a Promise. ## Job can be a string to send to the shell, ## or an object with a `job` string property, ## or an object with `input` and `output` properties for conversion. @jobs++ job = {job} if typeof job == 'string' new Promise (resolve, reject) => @queue.push {job, resolve, reject} @update() .then (result) => @emit 'ran', result result .catch (error) => @emit 'error', error # throws if no error listeners wait: -> ## Returns a Promise that resolves once all pending jobs are complete. ## Only one wait() can be active at a time. new Promise (@waiting) => @update() close: -> ## Close all Inkscape processes once all pending jobs are complete. ## Returns a Promise. @closing = true @wait() update: -> ## Potentially push jobs from queue or closing to Inkscape processes. return unless @queue.length or @waiting or @closing ## Filter out any Inkscape processes that died, e.g. from idle timeout. @inkscapes = (inkscape for inkscape in @inkscapes when not inkscape.dead) ## Check for completed waiting. if @waiting and @jobs <= 0 ## Schedule close() promise to resolve after job promise resolves. setTimeout => @waiting() @waiting = null , 0 return ## Give jobs to any ready Inkscape processes. for inkscape in @inkscapes if inkscape.ready if @queue.length @runNow inkscape, @queue.shift() return unless @queue.length or @closing else if @closing inkscape.close() ## If we still have jobs, start another Inkscape process to run them. ## On Windows, spawning is slow and spawning multiple Inkscapes at once ## slows down all spawns (including the first), so only spawn one at a time. ## On Linux, spawning is fast, so this isn't a big penalty. ## This also avoids spawning many Inkscapes if everything can be finished ## quickly with the first spawned Inkscape. if not @spawning and @queue.length and @inkscapes.length < @settings.jobs @spawning = true @inkscapes.push inkscape = new Inkscape @settings inkscape.open @inkscapes.length > 1 .then => @spawning = false @update() .catch (error) => throw new InkscapeError "Failed to spawn Inkscape: #{error.message}" + if error.code == 'ENOENT' ' (check PATH environment variable?)' else '' undefined runNow: (inkscape, {job, resolve, reject}) -> inkscape.run job .then (data) => @update() await @sanitize job.outputAbs ? job.output if job.output? data .then (data) => resolve data @jobs-- @update() .catch (error) => error[key] = value for key, value of job reject error sanitize: (output) -> ## Sanitize generated file. Returns a Promise. return unless @settings.sanitize switch when output.endsWith '.pdf' ## Blank out /CreationDate in PDF for easier version control. ## Replace these commands with spaces to avoid in-file pointer errors. buffer = Buffer.alloc @settings.bufferSize fileSize = (await fs.stat output).size position = Math.max 0, fileSize - @settings.bufferSize file = await fs.open output, 'r+' readSize = await file.read buffer, 0, @settings.bufferSize, position string = buffer.toString 'binary' ## must use single-byte encoding! match = /\/CreationDate\s*\((?:[^()\\]|\\[^])*\)/.exec string if match? await file.write ' '.repeat(match[0].length), position + match.index await file.close() watch: (inputs, formats) -> inputs = [inputs] if typeof inputs == 'string' formats = formats[0] if formats.length == 1 array = Array.isArray formats watchers = {} timeouts = {} status = {} handle = (input, force) => clearTimeout timeouts[input] if timeouts[input]? if status[input] == 'converting' status[input] = 'changed' else if not status[input] ## Restart watcher in case inode changed. if watchers[input]? watchers[input].close() delete watchers[input] watchFile input ## Wait for file to settle. timeouts[input] = setTimeout => ## If timeout actually resolves, file has settled. status[input] = 'converting' if force? oldSettings = @settings @settings = {...oldSettings, force} (if array Promise.allSettled @convertTo input, formats else @convertTo input, formats ).finally => @settings = oldSettings if force? ## If file changed during conversion, schedule forced conversion. current = status[input] delete status[input] if current == 'changed' handle input, true , @settings.settle watchFile = (input) => try watchers[input] ?= fsNormal.watch input, => handle input .on 'error', (error) => @emit 'error', error catch error if error.code == 'ENOENT' console.log ". #{input} no longer exists" ## Cancel conversion job about to be started setImmediate => clearTimeout timeouts[input] if timeouts[input]? else @emit 'error', error for input in inputs {type, input} = await @parseGlob input if type == 'file' watchFile input else do (input) => watchDir = (dir) => ## Watch a directory for new/newly named files, ## which triggers re-evaluating glob to see if new files to watch. watchers[dir] ?= fsNormal.watch dir, (eventType) => find true #if eventType == 'rename' .on 'error', (error) => if error.code in ['ENOENT', 'EPERM'] console.log ". #{dir} no longer exists" delete watchers[dir] else @emit 'error', error find = (convert) => ## Evaluate glob, watch all matching files for changes, ## and watch all prefix directories for new files as well, ## as they might affect the glob. ## Also convert newly matching files if specified. @makeGlob input, nodir: true .on 'match', (file) => handle file if convert and not watchers[file]? watchFile file for slash from file.matchAll '/' watchDir file[...slash.index] watchDir '.' unless file.startsWith '/' find() undefined help = -> console.log """ svgink #{metadata.version} Usage: #{process.argv[1]} (...options and filenames/directories/globs...) Documentation: https://github.com/edemaine/svgink Filenames or glob patterns should specify SVG files. Directories implicitly refer to *.svg within the directory. Optional arguments: -h / --help Show this help message and exit. -p / --pdf Convert SVG files to PDF via Inkscape -P / --png Convert SVG files to PNG via Inkscape -w / --watch Continuously watch for changed files and convert them -f / --force Force conversion even if output newer than SVG input -o DIR / --output DIR Write all output files to directory DIR --op DIR / --output-pdf DIR Write all .pdf files to directory DIR --oP DIR / --output-png DIR Write all .png files to directory DIR --clean Delete PDF/PNG files that would be generated -i PATH / --inkscape PATH Specify PATH to Inkscape binary --no-sanitize Don't sanitize PDF output by blanking out /CreationDate --relative Run jobs with relative paths (default uses absolute) -j N / --jobs N Run up to N Inkscape jobs in parallel """ main = (args = process.argv[2..]) -> start = new Date settings = {...defaultSettings} files = input: 0 output: 0 skip: 0 processor = new SVGProcessor settings .on 'input', => files.input++ .on 'converted', (data) => files.output++ if data.skip files.skip++ console.log "- #{data.input} -> #{data.output} (skipped)" else console.log "* #{data.input} -> #{data.output}" console.log data.stdout if data.stdout console.log data.stderr if data.stderr .on 'cleaned', (data) => files.output++ if data.skip files.skip++ console.log "- #{data.output} (already cleaned)" else console.log "* #{data.output} CLEANED" .on 'error', (error) => if error.input? console.log "! #{error.input} -> #{error.output} FAILED" else console.log "! Unknown error" console.log error watch = false formats = [] inputs = [] skip = 0 for arg, i in args if skip skip-- continue switch arg when '-h', '--help' help() when '-w', '--watch' watch = true when '-f', '--force' settings.force = true when '-i', '--inkscape' skip = 1 settings.inkscape = args[i+1] when '-o', '--output' skip = 1 settings.outputDir = args[i+1] when '--op', '--output-pdf' skip = 1 settings.outputDirExt['.pdf'] = args[i+1] when '--oP', '--output-png' skip = 1 settings.outputDirExt['.png'] = args[i+1] when '--clean' settings.clean = true when '-p', '--pdf' formats.push 'pdf' when '-P', '--png' formats.push 'png' when '--no-sanitize' settings.sanitize = false when '--relative' settings.relative = true when '-j', '--jobs' skip = 1 arg = parseInt args[i+1] if arg settings.jobs = arg else console.warn "Invalid argument to --jobs: #{args[i+1]}" else inputs.push input = arg processor.convertGlob input, formats if watch await processor.wait() else await processor.close() unless formats.length console.log '! Not enough formats. Specify --pdf and/or --png.' help() else if not files console.log '! Not enough filename arguments' help() else if settings.clean console.log "> Cleaned #{files.output - files.skip} out of #{files.output} files that would be generated by the #{files.input} SVG files in #{Math.round((new Date) - start) / 1000} seconds" else console.log "> Converted #{files.input} SVG files into #{files.output} files (#{files.output - files.skip} updated) in #{Math.round((new Date) - start) / 1000} seconds" console.log "> Skipped #{files.skip} conversions. To force conversion, use --force" if files.skip if watch console.log '> Watching for changes... (Ctrl-C to exit)' processor.watch inputs, formats module.exports = { defaultSettings InkscapeError Inkscape SVGProcessor main } main() if module? and require?.main == module #setTimeout(log, 5000).unref()