Class: Squared::Workspace::Project::Node

Inherits:

Git

• Object
• Base
• Git
• Squared::Workspace::Project::Node

Defined in:

lib/squared/workspace/project/node.rb

Constant Summary

Constants included from Common

Common::ARG, Common::PATH

Instance Attribute Summary

Attributes inherited from Base

#children, #dependfile, #exception, #group, #name, #parent, #path, #pipe, #project, #theme, #verbose, #workspace

Class Method Summary

• .aliasargs ⇒ Object
• .bannerargs ⇒ Object
• .batchargs ⇒ Object
• .config?(val) ⇒ Boolean
• .prod? ⇒ Boolean
• .tasks ⇒ Object

Instance Method Summary

• #bump(flag = :patch, val = nil, workspace: false) ⇒ Object
• #compose(target, opts = nil, script: false, args: nil, from: nil) ⇒ Object
• #copy(from: 'build', into: 'node_modules', scope: nil, also: nil, create: nil, files: nil, workspace: false, link: false, force: false, override: false, sync: invoked_sync?('copy'), **kwargs) ⇒ Object
• #depend(flag = nil, sync: invoked_sync?('depend', flag), packages: [], save: nil, exact: nil, omit: env('NPM_OMIT')) ⇒ Object
• #depend? ⇒ Boolean
• #dependbin ⇒ Object
• #dependtype(prog) ⇒ Object
• #dev? ⇒ Boolean
• #initialize(ts: 'tsconfig.json', asdf: 'nodejs', **kwargs) ⇒ Node constructor

  A new instance of Node.

• #outdated(flag = nil, opts = [], sync: invoked_sync?('outdated', flag)) ⇒ Object
• #outdated? ⇒ Boolean
• #pack(opts = []) ⇒ Object
• #package(flag, opts = [], packages: [], from: nil) ⇒ Object
• #packagename ⇒ Object
• #pnpm? ⇒ Boolean
• #populate ⇒ Object
• #prod? ⇒ Boolean
• #publish(flag = nil, sync: invoked_sync?('publish', flag), otp: nil, tag: nil, access: nil, dryrun: nil, version: nil, stage: [], registry: nil, ext: [], workspace: false) ⇒ Object
• #ref ⇒ Object
• #refresh? ⇒ Boolean
• #scripts ⇒ Object
• #serve(root, opts = [], bind: nil, port: 3000) ⇒ Object
• #tsc(*args, with: nil, pass: , sync: true, banner: verbose?, , from: :tsc, **kwargs) ⇒ Object
• #update ⇒ Object
• #update? ⇒ Boolean
• #version ⇒ Object
• #workspaces? ⇒ Boolean
• #yarn? ⇒ Boolean

Methods inherited from Git

#autostash, #branch, #checkout, #clean, #clone, #clone?, #commit, #diff, #enabled?, #fetch, #generate, #git, #log_, #ls_files, #ls_remote, #merge, #pull, #rebase, #reset, #restore, #rev_parse, #revbuild, #revbuild?, #show, #sparse_checkout, #stash, #status, #submodule, #switch, #tag

Methods inherited from Base

#<=>, #==, #add, #allref, #archive, #archive?, #as, #asdf, #basepath, #basepath!, #build, #build?, #chain, #clean, #clean?, #copy?, #dependname, #doc, #doc?, #each, #empty?, #enabled?, #error, #event, #exclude?, #exist?, #first, #generate, #global, #global=, #global_set, #graph, #graph?, #has?, #inject, #inspect, #last, #lint, #lint?, #localname, #log, options, populate, #prereqs, #prereqs?, ref, #ref?, #rootpath, #run, #scope, #script?, #scriptdata, #scriptname, #series, subtasks, #task_include?, #test, #test?, to_s, #to_s, #to_sym, #unpack, #variable_set, #version=, #with

Methods included from Common::Format

emphasize, #enable_aixterm, #enable_drawing, message

Constructor Details

#initialize(ts: 'tsconfig.json', asdf: 'nodejs', **kwargs) ⇒ Node

Returns a new instance of Node.

# File 'lib/squared/workspace/project/node.rb', line 172

def initialize(*, ts: 'tsconfig.json', asdf: 'nodejs', **kwargs)
  super
  if @pass.include?(Node.ref)
    initialize_ref Node.ref
    initialize_logger kwargs[:log]
  else
    initialize_build(Node.ref, prod: prod?, **kwargs)
    initialize_env(**kwargs)
  end
  @dependname = 'package.json'
  dependfile_set [@dependname]
  serve_set kwargs[:serve]
  @tsfile = basepath! ts
  @pm = { __: kwargs[:init] }
end

Class Method Details

.aliasargs ⇒ Object

# File 'lib/squared/workspace/project/node.rb', line 140

def aliasargs
  [ref, { refresh: :build }].freeze
end

.bannerargs ⇒ Object

# File 'lib/squared/workspace/project/node.rb', line 144

def bannerargs
  %i[version dependfile].freeze
end

.batchargs ⇒ Object

# File 'lib/squared/workspace/project/node.rb', line 136

def batchargs
  [ref, { refresh: %i[build copy] }].freeze
end

.config?(val) ⇒ Boolean

Returns:

• (Boolean)

# File 'lib/squared/workspace/project/node.rb', line 152

def config?(val)
  return false unless (val = as_path(val))

  val.join('package.json').exist?
end

.prod? ⇒ Boolean

Returns:

• (Boolean)

# File 'lib/squared/workspace/project/node.rb', line 148

def prod?
  ENV['NODE_ENV'] == 'production'
end

.tasks ⇒ Object

# File 'lib/squared/workspace/project/node.rb', line 132

def tasks
  %i[outdated update publish].freeze
end

Instance Method Details

#bump(flag = :patch, val = nil, workspace: false) ⇒ Object

# File 'lib/squared/workspace/project/node.rb', line 1235

def bump(flag = :patch, val = nil, workspace: false)
  if read_package('private')
    return if workspace

    each(accept: 'N', ref: Node.ref, from: 'bump') { |proj| proj.bump(flag, val, workspace: true) }
  elsif val ||= version && sembump(version, flag)
    begin
      doc = dependfile.read
      unless doc.sub!(/"version"\s*:\s*"#{version}"/, "\"version\": \"#{val}\"")
        raise message('version not found', hint: dependfile)
      end

      unless dryrun?
        log.info "bump version #{version} to #{val.subhint(flag)}"
        on :first, :bump
        dependfile.write(doc)
      end
      if stdin?
        puts val
      elsif !silent?
        major = flag == :major
        emphasize("version: #{val}", title: name, border: borderstyle, sub: [
          headerstyle,
          opt_style(color(major ? :green : :yellow), /\A(version:)( )(\S+)(.*)\z/, 3),
          opt_style(theme[major ? :major : :active], /\A(version:)(.*)\z/)
        ])
      end
      unless dryrun?
        commit(:add, [dependname], pass: true)
        on :last, :bump
      end
    rescue => e
      on_error(e, dryrun: dryrun?)
    end
  end
end

#compose(target, opts = nil, script: false, args: nil, from: nil) ⇒ Object

# File 'lib/squared/workspace/project/node.rb', line 1336

def compose(target, opts = nil, script: false, args: nil, from: nil, **)
  return unless target

  if script
    ret = session dependbin, 'run'
    raise message(dependbin, 'run', target, hint: from) unless append_any(target, build: true)

    append_any opts if opts
    append_loglevel
    append_any(args, delim: true) if args
    ret
  else
    case target
    when String
      target
    when Hash
      append_hash(target, target: []).join(' ')
    when Enumerable
      target.to_a.join(' ')
    else
      raise TypeError, message('unknown', target, hint: 'compose')
    end
  end
end

#copy(from: 'build', into: 'node_modules', scope: nil, also: nil, create: nil, files: nil, workspace: false, link: false, force: false, override: false, sync: invoked_sync?('copy'), **kwargs) ⇒ Object

# File 'lib/squared/workspace/project/node.rb', line 438

def copy(from: 'build', into: 'node_modules', scope: nil, also: nil, create: nil, files: nil, workspace: false,
         link: false, force: false, override: false, sync: invoked_sync?('copy'), **kwargs)
  return if @copy == false

  glob = kwargs[:include]
  pass = kwargs[:exclude]
  if @copy && !override
    return super unless @copy.is_a?(Hash)

    from = @copy[:from] if @copy.key?(:from)
    into = @copy[:into] if @copy.key?(:into)
    files = @copy[:files] if @copy.key?(:files)
    workspace = @copy[:workspace] if @copy.key?(:workspace)
    link = @copy[:link] if @copy.key?(:link)
    force = @copy[:force] if @copy.key?(:force)
    scope = @copy[:scope] if @copy.key?(:scope)
    also = @copy[:also] if @copy.key?(:also)
    create = @copy[:create] if @copy.key?(:create)
    glob = @copy[:include] if @copy.key?(:include)
    pass = @copy[:exclude] if @copy.key?(:exclude)
  end
  items = []
  if build? && path != @workspace.home && @workspace.home?
    items << @workspace.home
    @workspace.rev_clear(@workspace.find(@workspace.home).name, sync: sync)
  end
  items.concat(as_a(also)) if also
  return if items.empty?

  on :first, :copy
  print_item unless @output[0] || silent? || task_invoked?(/^copy(:#{Node.ref}|$)/)
  packed = false
  items.each do |dir|
    case dir
    when Pathname
      dest = dir
      @workspace.rev_clear(dest, sync: sync)
    when String
      dest = @workspace.rootpath(dir)
      @workspace.rev_clear(dest, sync: sync)
    when Symbol
      dest = if (proj = @workspace.find(name: dir))
               @workspace.rev_clear(proj.name, sync: sync)
               proj.path
             else
               log.warn message('target not found', dir, hint: 'copy')
               nil
             end
    when Hash
      from = dir[:from] if dir.key?(:from)
      into = dir[:into] if dir.key?(:into)
      scope = dir[:scope] if dir.key?(:scope)
      link = dir[:link] if dir.key?(:link)
      force = dir[:force] if dir.key?(:force)
      dest = dir[:target]
      create = dir[:create]
      workspace = dir[:workspace]
      glob = dir[:include]
      pass = dir[:exclude]
      dest = items.first unless dest && dest != true
      @workspace.rev_clear(dest, sync: sync) unless dest == true
    when Project::Base
      dest = dir.path
      @workspace.rev_clear(dir.name, sync: sync)
    else
      raise TypeError, message('unknown', dir, hint: 'copy')
    end
    next unless from && dest&.directory?

    if from == :npm
      begin
        unless packed
          require 'open3'
          cmd = session_output 'npm', 'pack --dry-run --no-color', npmname
          files = pwd_set(cmd, from: :'npm:pack') do
            Open3.capture2e(cmd.to_s)
                 .first
                 .scan(/^npm notice \d+(?:\.\d+)?[a-z]+ (.+)$/i)
                 .map { |item| Pathname.new(item.first) }
                 .select(&:exist?)
          end.concat(Array(files))
          packed = true
        end
        base = dest.join(into, npmname)
        base.mkpath
        log.info "cp npm:#{npmname} #{base}"
        errors = 0
        subdir = files.each_with_object([]) do |file, out|
          s, d = file.is_a?(Array) ? file : [file] * 2
          dest = base + d
          target = dest.dirname
          unless out.include?(dirname = target.to_s)
            target.mkpath
            out << dirname
          end
          FileUtils.cp(basepath(s), dest, verbose: !silent?)
        rescue => e
          print_error(Logger::ERROR, e, subject: name)
          errors += 1
        end
      rescue => e
        on_error e, :copy
      else
        puts message(base, subdir.size, files.size - errors) unless silent?
      end
      next
    end
    glob = Array(glob || '**/*')
    target = []
    from = basepath from
    if workspace
      from.glob('*').each do |entry|
        next unless entry.directory?

        sub = if (proj = @workspace.find(entry))
                proj.packagename
              elsif (file = entry + dependname).exist?
                begin
                  doc = JSON.parse(file.read)
                  doc['name']
                rescue => e
                  print_error(Logger::ERROR, e, subject: proj.name)
                end
              end
        if sub
          target << [entry, dest.join(into, sub)]
        else
          log.debug message("missing #{dependname} in \"#{entry}\"", hint: 'copy')
        end
      end
    else
      target << [from, dest.join(into, scope || npmname)]
    end
    target.each do |src, to|
      glob.each { |val| log.info "cp #{from + val} #{to}" }
      copy_dir(src, to, glob, create: create, link: link, force: force, pass: pass, verbose: !silent?)
    rescue => e
      on_error e
    end
  end
  on :last, :copy
end

#depend(flag = nil, sync: invoked_sync?('depend', flag), packages: [], save: nil, exact: nil, omit: env('NPM_OMIT')) ⇒ Object

# File 'lib/squared/workspace/project/node.rb', line 581

def depend(flag = nil, *, sync: invoked_sync?('depend', flag), packages: [], save: nil, exact: nil,
           omit: env('NPM_OMIT'), **)
  if @depend && !flag
    super
  elsif outdated?
    workspace.rev_clear(name, sync: sync)
    return update if !flag && (env('UPDATE') || env('NODE_UPDATE'))

    add = flag == :add
    if add
      remove, packages = packages.partition { |val| val.delete_prefix!('-') }
      remove.quote!
    end
    save, exact, omit = save if save.is_a?(Array)
    ws = env('NODE_WORKSPACES', equals: '0')
    om = lambda do |cmd|
      if omit
        save = case save
               when 'peer'
                 'optional'
               when 'optional'
                 'dev'
               when 'dev'
                 'prod'
               end
      end
      return unless save && save != 'bundle'

      cmd << "--#{save}"
    end
    rm = lambda do |target|
      return if remove.empty?

      run(target.temp(*remove).sub!(/ (add|install) /, ' remove '), sync: sync, from: :remove)
    end
    yarn = dependtype(:yarn)
    if yarn > 0
      if !flag && yarn > 1 && prod?
        cmd = session 'yarn', 'workspaces focus --all --production'
      else
        cmd = session('yarn', flag || 'install')
        if yarn == 1
          cmd << '--production' if prod?
          cmd << '--ignore-engines' if option('ignore-engines')
          cmd << '--ignore-scripts' if option('ignore-scripts')
          cmd << '--force' if option('force')
        else
          cmd << '--mode=skip-build' if option('ignore-scripts')
          cmd << '--check-cache' if !flag && option('force')
        end
        if nolockfile?(prefix: 'yarn')
          cmd << '--no-lockfile'
        elsif option('ci')
          if yarn == 1
            cmd << '--frozen-lockfile'
          elsif !flag
            cmd << '--immutable' << '--refresh-lockfile'
          end
        end
        if add
          cmd << '-W' if yarn == 1 && option('w', 'ignore-workspace-root-check', notequals: '0')
          rm.call(cmd)
          om.call(cmd)
          cmd << '--exact' if exact
        end
      end
      append_loglevel
    elsif pnpm?
      cmd = session('pnpm', flag || 'install')
      append_nocolor
      append_loglevel
      if add
        om.call(cmd)
        rm.call(cmd)
        cmd << '--save-exact' if exact
        option('allow-build') { |val| cmd << quote_option('allow-build', val) }
      else
        cmd << '--prod' if prod?
        append_platform
      end
      option('public-hoist-pattern') do |val|
        split_escape(val) { |opt| cmd << shell_option('public-hoist-pattern', opt) }
      end
      cmd << '--ignore-workspace' if ws
      cmd << if option('force')
               '--force'
             elsif nolockfile?(prefix: 'pnpm')
               '--no-lockfile'
             elsif option('ci')
               '--frozen-lockfile'
             end
      cmd << '--ignore-scripts' if option('ignore-scripts')
      cmd << '--dangerously-allow-all-builds' if option('approve-builds')
    else
      cmd = session 'npm'
      cmd << (ci = option('ci') ? 'ci' : 'install')
      option('approve-scripts') do |val|
        cmd = npm_output 'approve-scripts'
        cmd << case val
               when '1'
                 '--all --no-allow-scripts-pin'
               when 'true', 'all'
                 '--all'
               else
                 val.split(/\s+/).quote!.join(' ')
               end
        print_run cmd, silent?
        run(cmd, banner: false)
      end
      cmd << '--workspaces=false' if ws
      cmd << '--force' if option('force')
      append_nocolor
      append_loglevel
      if omit
        cmd << "--omit=#{save || omit}"
        save = nil
      elsif !add && prod?
        cmd << '--include=prod'
      end
      unless ci
        if add
          cmd << "--save-#{save}" if save
          rm.call(cmd)
          cmd << '--save-exact' if exact
        else
          append_platform
        end
      end
      cmd << '--package-lock=false' << 'save=false' if nolockfile?(prefix: 'npm')
      cmd << '--ignore-scripts' if option('ignore-scripts')
    end
    if add
      return if packages.empty?

      cmd.merge(packages.quote!)
    end
    run(sync: sync, from: flag || :depend)
  end
end

#depend? ⇒ Boolean

Returns:

• (Boolean)

# File 'lib/squared/workspace/project/node.rb', line 1385

def depend?
  @depend != false && (!@depend.nil? || outdated?)
end

#dependbin ⇒ Object

# File 'lib/squared/workspace/project/node.rb', line 1455

def dependbin
  yarn? ? 'yarn' : pnpm? ? 'pnpm' : 'npm'
end

#dependtype(prog) ⇒ Object

# File 'lib/squared/workspace/project/node.rb', line 1448

def dependtype(prog)
  return @pm[prog] if @pm.key?(prog)

  meth = :"#{prog}?"
  respond_to?(meth) && __send__(meth) ? @pm[prog] : 0
end

#dev? ⇒ Boolean

Returns:

• (Boolean)

# File 'lib/squared/workspace/project/node.rb', line 1440

def dev?
  super && (!Node.prod? || (@dev == true && !prod?))
end

#outdated(flag = nil, opts = [], sync: invoked_sync?('outdated', flag)) ⇒ Object

# File 'lib/squared/workspace/project/node.rb', line 721

def outdated(flag = nil, opts = [], sync: invoked_sync?('outdated', flag))
  cmd = session(pnpm? && exist?('pnpm-lock.yaml') ? 'pnpm' : 'npm', 'outdated')
  dryrun = has_value?(opts, 'd', 'dry-run') || dryrun?
  unless dryrun
    log.info cmd.to_s
    on :first, :outdated
  end
  banner = format_banner(cmd.temp(('--dry-run' if dryrun)))
  print_item banner if sync
  begin
    data = pwd_set(cmd, dryrun: dryrun) { `#{cmd.temp('--json --loglevel=error')}` }
    doc = dependfile.read
    json = JSON.parse(doc)
    dep1 = json['dependencies'] || {}
    dep2 = json['devDependencies'] || {}
    target = json['name']
  rescue => e
    on_error(e, dryrun: dryrun)
    return
  end
  found = []
  avail = []
  flag ||= case (up = option('u', 'update'))
           when 'major', 'minor'
             up.to_sym
           else
             prod? ? :patch : :minor
           end
  if sync && !stdin?
    items = if has_value?(opts, 's', 'select')
              se = true
              []
            elsif has_value?(opts, 'i', 'interactive')
              ia = true
              []
            end
  end
  unless data.empty?
    JSON.parse(data).each_pair do |key, val|
      val = val.find { |obj| obj['dependent'] == target } if val.is_a?(Array)
      next unless val && (file = dep1[key] || dep2[key]) && file != '*'

      latest = val['latest']
      ch = file[0]
      if ch.match?(/[~^]/)
        file = file[1..-1]
      elsif ia && flag == :major
        major = true
      else
        avail << [key, file, latest, true]
        next
      end
      current = val['current'] || file
      want = val['wanted']
      unless latest[SEM_VER, 6]
        case flag
        when :major
          want = latest
        when :minor
          want = latest if latest[SEM_VER, 1] == want[SEM_VER, 1]
        when :patch
          if (g = latest.match(SEM_VER)) && (h = want.match(SEM_VER)) && g[1] == h[1] && g[3] == h[3]
            want = latest
          end
        end
      end
      next unless (current != want || file != want) && (want.match?(SEM_VER) || !file.match?(SEM_VER))

      f = semscan(file, fill: !option('save-exact').nil?)
      w = semscan want
      a = f[0]
      b = f[2]
      c = w[0]
      d = w[2]
      upgrade = case flag
                when :major
                  a == '0' ? c == '0' || c == '1' : true
                when :minor
                  next unless f[4]

                  ch == '^' && (a == '0' ? c == '0' && b == d : a == c)
                when :patch
                  next unless b && f[4]

                  a == c && b == d && f[4] != w[4]
                end
      if upgrade && !w[6]
        next if file == want

        found << [key, file, want, if a != c
                                     1
                                   elsif b != d
                                     a == '0' ? 1 : 3
                                   else
                                     5
                                   end, major, semscan(file), w]
      elsif !major
        avail << [key, file, latest, latest != current]
      end
    end
  end
  pending = 0
  modified = 0
  width = ->(a, i) { a.map { |aa| aa[i] }.max_by(&:size).size }
  pad = ->(val, ord) { val.succ.to_s.rjust([ord.size.to_s.size, 2].max) }
  footer = lambda do |val, size|
    return unless verbose

    msg, hint = if modified == -1
                  ['Packages were updated', 'more possible']
                else
                  ['No packages were updated', 'possible']
                end
    possible = pending + val
    puts print_footer(empty_status(msg, hint, possible == size ? 0 : possible))
  end
  print_item banner unless sync
  if !found.empty?
    col1 = width.call(found, 0) + 4
    col2 = width.call(found, 1) + 4
    col3 = pad.call(found.size, found).size + 2 + col1 + col2 + width.call(found, 2)
    packages = []
    pat = ->(a) { /("#{Regexp.escape(a[0])}"\s*:\s*)"([~^])#{'?' if a[4]}#{Regexp.escape(a[1])}"/ }
    edit = lambda do |a, pkg, mod|
      packages << a[0]
      modified += 1
      "#{pkg}\"#{mod || (a[3] == 1 && a[4] ? '^' : '')}#{a[2]}\""
    end
    found.each_with_index do |item, i|
      a, b, c, d, e = item
      cur = modified
      doc.send(items ? :sub : :sub!, pat.call(item)) do |capture|
        if $2 == '~' && flag != :patch
          cur = -1
          pending += 1
          capture
        else
          edit.call(item, $1, $2)
        end
      end
      a = a.ljust(col1)
      b = b.ljust(col2)
      sub_style! b, theme[:current] if theme[:current] && !stdin?
      if cur == -1
        c = 'SKIP'
      elsif modified == cur
        c = 'FAIL'
      elsif !stdin?
        if d == 1
          sub_style! a, theme[:major]
          sub_style! c, :bold, color(:green)
        else
          sub_style!(c, **opt_style(color(d == 3 ? :green : :yellow), SEM_VER, d))
        end
        g = item
      end
      s = "#{pad.call(i, found)}. #{a}#{b}#{c}"
      if se
        items << [s, g]
        next
      elsif ia && g
        items << [g]
        if flag != :major || e || semmajor?(item[5], item[6])
          items.pop unless confirm_semver(s.ljust(col3 + s.size - s.stripstyle.size), (d / 2.0).ceil)
          next
        end
      end
      puts s
    end
    pending = avail.reduce(pending) { |a, b| a + (b[3] ? 0 : 1) }
    if (dryrun && Array(items).empty?) || (modified == 0 && (pending > 0 || (items && pending == 0)))
      n = if items
            if items.empty?
              puts 'No updates were selected'
              0
            else
              puts items.map(&:first) if se
              items.size
            end
          else
            found.size
          end
      footer.call(modified, n) unless n == 0
    elsif modified > 0
      if items
        packages.clear
        if ia
          (1..items.size)
        else
          choice('Select a package', items.map(&:first), multiple: true, force: false, index: true,
                                                         border: true)
        end.each do |n|
          item = items[n.pred].last
          doc.sub!(pat.call(item)) { edit.call(item, $1, $2) }
        end
      end
      unless packages.empty?
        modified = -1
        if dryrun
          footer.call(0, found.size)
        else
          File.write(dependfile, doc)
          if sync && (opts.include?('diff') || option('diff'))
            run(git_output('diff', shell_quote(dependfile)), banner: false)
          end
          if has_value?(opts, 'u', 'update') || up
            package(:update, packages: packages, from: :'outdated:update')
          else
            footer.call(0, found.size)
          end
          printsucc
          commit(:add, [dependname], pass: true)
        end
      end
    end
  elsif !avail.empty?
    col1 = width.call(avail, 0) + 4
    col2 = width.call(avail, 1)
    col3 = width.call(avail, 2) + 4
    avail.each_with_index do |item, i|
      a, b, c, d = item
      a = a.ljust(col1)
      b = sub_style b.ljust(col2), color(d ? :red : :yellow)
      c = c.ljust(col3)
      unless d
        sub_style! a, theme[:active]
        sub_style! c, color(:green)
        pending += 1
      end
      puts "#{pad.call(i, avail)}. #{(a + c + b).subhint(d ? 'locked' : 'latest')}"
    end
    footer.call(0, avail.size)
  else
    puts 'No updates were found'
  end
  on :last, :outdated unless dryrun
end

#outdated? ⇒ Boolean

Returns:

• (Boolean)

# File 'lib/squared/workspace/project/node.rb', line 1389

def outdated?
  dependfile.exist? && !task_pass?('outdated')
end

#pack(opts = []) ⇒ Object

# File 'lib/squared/workspace/project/node.rb', line 1272

def pack(opts = [])
  return unless version

  cmd = session dependbin, 'pack'
  if dependtype(:yarn) > 1
    op = OptionPartition.new(opts, OPT_BERRY[:pack], cmd, project: self, strict: strict?)
    op.append?('out', Pathname.pwd + "#{project}-#{version}.tgz")
  else
    op = OptionPartition.new(opts, pnpm? ? OPT_PNPM[:pack] : npmopts(:pack), cmd, project: self,
                                                                                  strict: strict?)
    unless pnpm?
      op.each do |opt|
        next unless opt =~ op.values

        case $1
        when 'w', 'workspace'
          op << quotepath($1, $2)
          op.found << opt
        end
      end
    end
    op.append?('pack-destination', Dir.pwd)
  end
  op.clear
  run(from: :pack)
end

#package(flag, opts = [], packages: [], from: nil) ⇒ Object

# File 'lib/squared/workspace/project/node.rb', line 1089

def package(flag, opts = [], packages: [], from: nil)
  workspace.rev_clear(name)
  yarn = dependtype(:yarn)
  if yarn > 0 && !(yarn == 1 && ((flag == :update && !packages.empty?) || %i[approve deny
                                                                             rebuild].include?(flag)))
    cmd = session 'yarn', case flag
                          when :update
                            if yarn == 1
                              'upgrade'
                            else
                              spec = 0
                              'up'
                            end
                          when :reinstall
                            if yarn == 1
                              remove_modules(prefix: 'yarn') if opts.include?('force')
                            elsif opts.delete('force')
                              opts << 'check-cache'
                            end
                            opts << 'no-lockfile' if lockfile(true)
                            'install'
                          when :add
                            spec = 1
                            'add'
                          else
                            yarn == 1 && flag == :dedupe ? 'install' : flag
                          end
    op = OptionPartition.new(opts, if yarn == 1
                                     OPT_YARN.fetch(flag == :dedupe ? :install : flag, []) + OPT_YARN[:common]
                                   else
                                     OPT_BERRY.fetch(flag, []) + case flag
                                                                 when :add, :update then OPT_BERRY[:add_a]
                                                                 else []
                                                                 end
                                   end, cmd, project: self, strict: strict?)
    if yarn == 1 && flag != :reinstall
      op << '--no-lockfile' if nolockfile?(prefix: 'yarn')
      op << '--ignore-engines' if option('ignore-engines')
    end
  else
    flags = []
    args = if pnpm?
             if flag == :approve || flag == :deny
               opts.map! { |val| val.start_with?('!') ? val : "!#{val}" } if flag == :deny
               flag = :'approve-builds'
               spec = true
             else
               case flag
               when :install, :update
                 opts << 'no-lockfile' if nolockfile?(prefix: 'pnpm')
                 spec = 0 if flag == :update
               when :add
                 spec = 1
               when :reinstall
                 opts << 'force'
                 flag = :install
               end
               flags << :install_a unless flag == :rebuild
               unless flag == :dedupe
                 flags << :common_filter
                 unless flag == :add
                   flags << :install_b
                   flags << :common_cpu unless flag == :update
                 end
               end
               no = OPT_PNPM[:no][flag]
             end
             [
               opts,
               pnpmopts(flag, *flags),
               session('pnpm', flag)
             ]
           else
             if flag == :approve || flag == :deny
               flag = :"#{flag}-scripts"
               spec = true
             else
               case flag
               when :install, :update
                 opts.unshift('package-lock=false', 'save=false') if nolockfile?(prefix: 'npm')
                 spec = flag == :install ? 0 : 2
               when :add
                 spec = 1
                 flag = :install
               when :reinstall
                 remove_modules(prefix: 'npm') if opts.delete('force')
                 opts.unshift('package-lock=false') if lockfile(true)
                 flag = :install
               end
               unless flag == :rebuild
                 flags << :install_a
                 unless flag == :dedupe
                   %w[save ignore-scripts strict-peer-deps].each do |key|
                     option(key, prefix: 'npm', ignore: false) do |val|
                       opts << basic_option(key, case val
                                                 when '0', 'false'
                                                   false
                                                 else
                                                   true
                                                 end)
                     end
                   end
                   flags << :install_b << :common_scripts
                 end
                 flags << :install_c unless flag == :update
                 no = OPT_NPM[:no][:install]
               end
             end
             [
               opts,
               npmopts(flag, *flags),
               session('npm', flag)
             ]
           end
    op = OptionPartition.new(*args, no: no, project: self, strict: strict?)
    append_platform if flag == :install
    append_nocolor
  end
  append_loglevel
  case spec
  when Numeric
    op.each do |opt|
      if opt =~ op.values
        case $1
        when 'w', 'workspace'
          op << quotepath($1, $2)
        end
      elsif opt.match?(/^-|=/)
        op.errors << opt
      else
        op.found << (spec == 2 && (n = opt.index('@')) ? opt[0, n] : opt)
      end
    end
    op.swap.concat(packages)
    raise ArgumentError, 'no packages to add' if op.empty? && spec == 1

    op.append(quote: true)
      .clear(errors: true)
  when true
    op.append(quote: true)
  else
    op.clear
  end
  run(from: from || symjoin('package', flag))
end

#packagename ⇒ Object

# File 'lib/squared/workspace/project/node.rb', line 1463

def packagename
  read_package 'name'
end

#pnpm? ⇒ Boolean

Returns:

• (Boolean)

# File 'lib/squared/workspace/project/node.rb', line 1422

def pnpm?
  (@pm[:pnpm] ||= if rootpath('pnpm-lock.yaml', ascend: dependroot).exist?
                    pnpmtype
                  elsif (ver = read_package || read_install)
                    ver.start_with?('pnpm') ? pnpmtype : 0
                  else
                    @pm[:__] == 'pnpm' ? pnpmtype : 0
                  end) > 0
end

#populate ⇒ Object

# File 'lib/squared/workspace/project/node.rb', line 192

def populate(*, **)
  super
  return unless (outdated? && ref?(Node.ref)) || @only

  namespace name do
    Node.subtasks do |action, flags|
      next if task_pass?(action)

      if flags.nil?
        case action
        when 'add'
          format_desc action, nil, 'save?=[=-]prod|dev|optional|peer|bundle,(-)name+'
          task action, [:save] do |_, args|
            packages = if args.save =~ /^([=-]*)(prod|dev|optional|peer|bundle)$/
                         save = [$2, $1.include?('='), $1.include?('-')]
                         args.extras
                       else
                         save = 'prod'
                         args.to_a
                       end
            param_guard(action, 'name', args: packages)
            depend(:add, packages: packages, save: save)
          end
        when 'run'
          format_desc action, nil, "script,opts*|#{indexchar}index+|#,pattern*"
          task action, [:script] do |_, args|
            next if (list = scripts.to_a).empty?

            if args.script == '#'
              format_list(list, "run[#{indexchar}N]", 'scripts', grep: args.extras, from: dependfile)
            else
              args = param_guard(action, 'script', args: args.to_a)
              opts = args.each_with_object([]) do |val, out|
                if (n, extra = indexitem(val))
                  if (item = list[n.pred])
                    run compose([item.first, extra].compact.join(' '), script: true)
                  elsif exception?
                    indexerror n, list
                  else
                    log.warn "run script #{n} of #{list.size}".subhint('out of range')
                    next
                  end
                else
                  out << val
                end
              end
              next if opts.empty?

              yarn = dependtype(:yarn)
              list = if yarn > 0
                       yarn == 1 ? OPT_YARN[:run] + OPT_YARN[:common] : OPT_BERRY[:run]
                     elsif pnpm?
                       pnpmopts :run, :common_filter
                     else
                       npmopts :run
                     end
              OptionPartition.new(opts, list, session(dependbin, 'run'), project: self, strict: strict?)
                             .add_first
                             .append(delim: true, quote: false)
              run(from: :run)
            end
          end
        when 'exec'
          format_desc action, nil, 'pkg/cmd,opts*,args*'
          task action, [:package] do |_, args|
            if (package = args.package)
              args = args.extras
              cmd = if pnpm?
                      pre = ->(ch) { "-#{ch}" if args.delete(ch) }
                      list = pnpmopts :exec, :common_filter
                      session 'pnpm', pre.call('r'), pre.call('c'), 'exec'
                    else
                      list = npmopts :exec, :common_scripts
                      session 'npm', 'exec'
                    end
              op = OptionPartition.new(args, list, cmd, project: self, strict: strict?)
              if op.empty?
                op << package
                if (args = readline('Enter arguments', force: false))
                  op.delim unless pnpm?
                  op << args
                end
              else
                op.delim unless pnpm?
                op << package << op.join(' ')
              end
            else
              session 'npm', 'exec', quote_option('c', readline('Enter command', force: true), double: true)
            end
            run(from: :exec)
          end
        when 'nvm'
          next unless ENV['NVM_DIR'] && !workspace.windows?

          format_desc action, nil, 'version?,args*'
          task action, [:version] do |_, args|
            path = ->(s) { File.join(ENV['NVM_DIR'], s) }
            unless (version = args.version)
              cmd = ". #{path.call('nvm.sh')} && nvm list --no-colors --no-alias"
              version = pwd_set(from: :nvm) do
                choice_index('Select a version', IO.popen(cmd).map { |line| line[/\s(v\S+)/, 1] }, series: true)
              end
            end
            args = args.extras
            args << readline('Enter command', force: true) if args.empty?
            args.unshift(path.call('nvm-exec'))
            run(args.join(' '), { 'NODE_VERSION' => version }, banner: false, from: :nvm)
          end
        when 'bump'
          format_desc action, nil, 'version|pre?{major,minor,patch}|prerelease'
          task action, [:version] do |_, args|
            version = param_guard(action, 'to', args: args, key: :version)
            if version.match?(/^((pre)?(major|minor|patch))|prerelease$/)
              flag = version.to_sym
              version = nil
            else
              flag = :version
            end
            bump flag, version
          end
        when 'pack'
          format_desc action, nil, 'opts*'
          task action do |_, args|
            pack args.to_a
          end
        end
      else
        namespace action do
          flags.each do |flag|
            case action
            when 'outdated'
              format_desc action, flag, "#{shortname('i', 's', 'u', 'd')},diff"
              task flag do |_, args|
                outdated flag, args.to_a
              end
            when 'package'
              format_desc(action, flag, 'opts*', before: case flag
                                                         when :dedupe, :rebuild then nil
                                                         when :reinstall then 'force?'
                                                         else 'name*'
                                                         end)
              task flag do |_, args|
                package flag, args.to_a
              end
            when 'publish'
              if flag == :verify
                format_desc action, flag, 'version?,ext*'
                task flag, [:version] do |_, args|
                  ext = args.extras
                  if (version = args.version)&.match?(/^\.?[a-z]+$/i)
                    ext.unshift(version)
                    version = nil
                  end
                  publish(flag, version: version, ext: ext)
                end
              else
                format_desc(action, flag,
                            "otp?,#{'registry?,' if flag == :stage}p/ublic|r/estricted?,d/ry-run?",
                            before: case flag
                                    when :tag then 'tag'
                                    when :stage then '{select=view,approve,reject,download}|publish=tag?'
                                    end)
                task flag do |_, args|
                  args = args.to_a
                  access = nil
                  dryrun = nil
                  stage = []
                  parse = lambda do
                    access = if has_value!(args, 'r', 'restricted')
                               'restricted'
                             elsif has_value!(args, 'p', 'public')
                               'public'
                             end
                    dryrun = has_value!(args, 'd', 'dry-run')
                  end
                  case flag
                  when :stage
                    case args.first
                    when 'view', 'approve', 'reject', 'download'
                      out = pwd_set { `#{npm_output("stage list #{npmname} --json --loglevel=error")}` }
                      pad0 = 0
                      pad1 = 0
                      data = Array(parse_json(out, kind: Array)).map do |item|
                        ver = item['version']
                        tag = item['tag']
                        pad0 = [pad0, ver.size].max
                        pad1 = [pad1, tag.size].max
                        [ver, tag, item['id'], item['actor']]
                      end
                      if data.empty?
                        print_error('no staged releases', loglevel: Logger::INFO, subject: npmname)
                        exit 1
                      end
                      data.each do |item|
                        item[0] = item[0].rjust(pad0)
                        item[1] = item[1].rjust(pad1)
                      end
                      stage << args.shift
                      stage << choice_index('Select a release', data.map { |item| item.join('    ') },
                                            column: /^(?:\S+\s+){2}(\S+)/)
                      if %w[approve reject].include?(stage.first)
                        otp = args.shift if args.first&.match?(/^\d+$/)
                        registry = args.first
                        option('otp', prefix: 'npm') { |val| otp = val }
                        option('registry', prefix: 'npm') { |val| registry = val }
                      end
                    else
                      stage << 'publish'
                      parse.call
                      tag, otp = args
                    end
                  when :latest
                    parse.call
                    otp = args.first
                  else
                    parse.call
                    tag, otp = param_guard(action, flag, args: args)
                  end
                  publish(flag, otp: otp, tag: tag, access: access, stage: stage, registry: registry,
                                dryrun: dryrun)
                end
              end
            when 'tsc'
              break unless @tsfile

              format_desc(action, flag, 'opts*', "#{flag == :project ? 'before' : 'after'}": 'config?')
              task flag do |_, args|
                args = args.to_a
                if flag == :project
                  project = if exist?(args.first)
                              args.shift
                            else
                              @tsfile
                            end
                end
                watch = has_value!(args, 'w', 'watch')
                tsc(*args, banner: true, project: project, build: flag == :build, watch: !watch.nil?)
              end
            end
          end
        end
      end
    end
  end
end

#prod? ⇒ Boolean

Returns:

• (Boolean)

# File 'lib/squared/workspace/project/node.rb', line 1444

def prod?
  @prod != false && (Node.prod? || super)
end

#publish(flag = nil, sync: invoked_sync?('publish', flag), otp: nil, tag: nil, access: nil, dryrun: nil, version: nil, stage: [], registry: nil, ext: [], workspace: false) ⇒ Object

# File 'lib/squared/workspace/project/node.rb', line 963

def publish(flag = nil, *, sync: invoked_sync?('publish', flag), otp: nil, tag: nil, access: nil, dryrun: nil,
            version: nil, stage: [], registry: nil, ext: [], workspace: false)
  if read_package('private')
    return if workspace || !stage.empty?

    from, accept = flag == :verify ? %w[verify Y] : %w[publish N]
    each(accept: accept, ref: Node.ref, from: from) do |proj|
      proj.publish(flag, sync: sync, otp: otp, tag: tag, access: access, dryrun: dryrun, version: version,
                         ext: ext, workspace: true)
    end
  elsif version ||= self.version
    if flag == :verify
      require 'open-uri'
      require 'digest'
      ext = ext.map { |val| val[0] == '.' ? val : ".#{val}" }
      url = "https://unpkg.com/#{read_package('name')}@#{version}?meta"
      print_item format_banner(url, command: false)
      URI.open(url) do |f|
        doc = JSON.parse(f.read)
        n = doc['prefix'].size
        i = 0
        j = doc['files'].size
        pad = j.to_s.size
        m = 0
        c = 0
        e = 0
        doc['files'].each do |item|
          path = item['path'][n..-1]
          js = File.extname(path)
          next unless ext.empty? || ext.any? { |val| val == js }

          begin
            raise unless (file = basepath!(path)) && item['integrity'] =~ /^(sha\d+)-(.+)$/

            hash = case $1
                   when 'sha384'
                     Digest::SHA384
                   when 'sha512'
                     Digest::SHA512
                   else
                     Digest::SHA256
                   end
                   .base64digest(file.read)
            status = if hash == $2
                       m += 1
                       sub_style 'match', color(:green)
                     else
                       c += 1
                       sub_style 'check', theme[:caution]
                     end
          rescue
            status = sub_style 'error', theme[:warn]
            e += 1
          end
          i += 1
          puts "#{i.to_s.rjust(pad)}. #{status} #{path}"
        end
        if i == 0
          puts("No files #{ext.empty? ? 'found' : "matched: #{ext.join(', ')}"}")
        else
          total = ["match #{m}"]
          total << "check #{c}" unless c == 0
          total << "error #{e}" unless e == 0
          unless i == j
            s = "in #{j}"
            if total.size == 1
              total[0] += " #{s}"
            else
              total << s
            end
          end
          puts print_footer(total.join(' / '), right: true, sub: [
            opt_style(color(:green), /^(.*)(match)(.+)$/, 2),
            opt_style(theme[:caution], /^(.+)(check)(.+)$/, 2),
            opt_style(theme[:warn], /^(.+)(error)(.+)$/, 2)
          ])
        end
      end
    else
      args = ['npm']
      if stage.empty?
        args << 'publish'
      else
        args << 'stage' << stage.shift
        args.concat(stage)
      end
      cmd = session(*args)
      if stage.empty?
        otp ||= option('otp')
        cmd << basic_option('tag', tag.tr(' ', '-')) if tag ||= option('tag')
        case access || option('access')
        when 'p', 'public'
          cmd << '--access=public'
        when 'r', 'restricted'
          cmd << '--access=restricted'
        end
        dryrun ||= dryrun?(prefix: 'npm')
      end
      cmd << basic_option('otp', otp) if otp
      cmd << quote_option('registry', registry) if registry
      if dryrun
        cmd << '--dry-run'
      else
        log.info cmd.to_s
        from = symjoin args.take(3)
      end
      if sync
        run(sync: sync, from: from, interactive: !dryrun && stage.empty? && ['Publish', 'N', npmname])
      else
        require 'open3'
        on :first, from
        pwd_set(cmd, dryrun: dryrun) do
          cmd = session_done cmd
          Open3.popen2e(cmd) do |_, out|
            write_lines(out, banner: format_banner(cmd),
                             sub: npmnotice(opt_style(color(:bright_blue), /^(.+)(Tarball .+)$/, 2)))
          end
        end
        on :last, from
      end
    end
  elsif !workspace
    print_error('version not found', subject: name, hint: dependname)
  end
end

#ref ⇒ Object

# File 'lib/squared/workspace/project/node.rb', line 188

def ref
  Node.ref
end

#refresh? ⇒ Boolean

Returns:

• (Boolean)

# File 'lib/squared/workspace/project/node.rb', line 1397

def refresh?
  !Node.prod?
end

#scripts ⇒ Object

# File 'lib/squared/workspace/project/node.rb', line 1467

def scripts
  @scripts ||= read_package('scripts').yield_self { |ret| ret.is_a?(Hash) ? ret : {} }
end

#serve(root, opts = [], bind: nil, port: 3000) ⇒ Object

# File 'lib/squared/workspace/project/node.rb', line 1361

def serve(root, opts = [], bind: nil, port: 3000, **)
  var = {}
  if File.extname(root) =~ /[cm]?js/
    var['HOST'] = bind if bind
    var['PORT'] = port.to_s if port
    target = root
    root = File.dirname(target)
  else
    require 'tempfile'
    app = APP_SERVE.dup
    app.gsub!('$ROOT', root)
    app.gsub!('$HOST', bind || 'localhost')
    app.gsub!('$PORT', port.to_s)
    file = Tempfile.new([name, '.cjs'])
    file.write(app)
    file.close
    trap 'INT' do
      file.unlink
    end
    target = file.path
  end
  shell(var, session('node', shell_quote(target), *opts.map { |s| fill_option(s) }).done, chdir: root)
end

#tsc(*args, with: nil, pass: , sync: true, banner: verbose?, , from: :tsc, **kwargs) ⇒ Object

# File 'lib/squared/workspace/project/node.rb', line 1299

def tsc(*args, with: nil, pass: PASS_NODE[:tsc], sync: true, banner: verbose?, from: :tsc, **kwargs)
  session_apply(with, args: args, kwargs: kwargs, pass: pass) if with
  p = kwargs[:project]
  b = kwargs[:build]
  w = kwargs[:watch]
  list = OPT_TSC[:base] + OPT_TSC[:compiler]
  list.concat(Array(kwargs.fetch(:legacy, 5)).flat_map { |n| OPT_TSC.fetch(:"v#{n}", {}).fetch(:compiler, []) })
  cmd = session 'tsc', if p
                         quote_option 'p', basepath(p)
                       elsif b
                         list.concat(OPT_TSC[:build])
                         '-b'
                       end
  if w
    list.concat(OPT_TSC[:watch])
    cmd << '-w'
  end
  op = OptionPartition.new(args, list, cmd, project: self, strict: strict?, sep: ' ')
  unless p
    if b.is_a?(String)
      op.add_path(b)
    elsif w.is_a?(String)
      op.add_path(w)
    else
      op.exist?(add: true)
    end
  end
  op.clear
  cmd = session_done(op.target)
  print_run(cmd, banner, **kwargs)
  session 'npx', cmd
  start = time_epoch if kwargs.fetch(:verbose, verbose? && !stdin?)
  ret = run(sync: sync, banner: banner, exception: kwargs.fetch(:exception, exception?), from: from)
  print_status(name, subject: 'tsc', start: start) if success?(ret, banner, start.nil?) && start
  ret
end

#update ⇒ Object

# File 'lib/squared/workspace/project/node.rb', line 959

def update(*)
  package(:update, from: :update)
end

#update? ⇒ Boolean

Returns:

• (Boolean)

# File 'lib/squared/workspace/project/node.rb', line 1393

def update?
  outdated?
end

#version ⇒ Object

# File 'lib/squared/workspace/project/node.rb', line 1459

def version
  @version ||= read_package('version')
end

#workspaces? ⇒ Boolean

Returns:

• (Boolean)

# File 'lib/squared/workspace/project/node.rb', line 1432

def workspaces?
  if pnpm?
    exist?('pnpm-workspace.yaml')
  else
    read_package('workspaces').is_a?(Array)
  end
end

#yarn? ⇒ Boolean

Returns:

• (Boolean)

# File 'lib/squared/workspace/project/node.rb', line 1401

def yarn?
  (@pm[:yarn] ||= if rootpath('yarn.lock', ascend: dependroot).exist?
                    yarntype
                  elsif (ver = read_package || read_install)
                    if ver =~ /^yarn(?:@(\d)|$)/
                      $1 && $1.to_i > 1 ? yarntype : 1
                    else
                      0
                    end
                  else
                    case @pm[:__]
                    when 'yarn'
                      1
                    when 'berry'
                      yarntype
                    else
                      0
                    end
                  end) > 0
end