powerlines 0.47.124 → 0.47.126

package/bin/shared-BiFPKQIb.mjs

@@ -0,0 +1,235 @@
+import{C as e,S as t,a as n,b as r,c as i,d as a,h as o,j as s,l as c,m as l,p as u,x as d}from"./prompts-BnlPjHFR.mjs";const f=`function __cli_debug
+set -l file "$BASH_COMP_DEBUG_FILE"
+if test -n "$file"
+  echo "$argv" >> $file
+end
+end
+
+function __cli_perform_completion
+__cli_debug "Starting __cli_perform_completion"
+
+# Extract all args except the last one
+set -l args (commandline -opc)
+# Extract the last arg and escape it in case it is a space or wildcard
+set -l lastArg (string escape -- (commandline -ct))
+
+__cli_debug "args: $args"
+__cli_debug "last arg: $lastArg"
+
+# Build the completion request command
+set -l requestComp "/nix/store/8spcnffxayf4h9v8w075j01bxxgv5c8j-nodejs-slim-26.3.0/bin/node  /home/runner/work/powerlines/powerlines/node_modules/.pnpm/nx@22.7.5_@swc-node+register@1.11.1_@swc+core@1.15.40_@swc+helpers@0.5.23__@swc+types@0_559e3db9ab82faa3b71ca2061041f3f6/node_modules/nx/dist/bin/run-executor.js complete -- (string join ' ' -- (string escape -- $args[2..-1])) $lastArg"
+
+__cli_debug "Calling $requestComp"
+set -l results (eval $requestComp 2> /dev/null)
+
+# Some programs may output extra empty lines after the directive.
+# Let's ignore them or else it will break completion.
+# Ref: https://github.com/spf13/cobra/issues/1279
+for line in $results[-1..1]
+  if test (string trim -- $line) = ""
+    # Found an empty line, remove it
+    set results $results[1..-2]
+  else
+    # Found non-empty line, we have our proper output
+    break
+  end
+end
+
+set -l comps $results[1..-2]
+set -l directiveLine $results[-1]
+
+# For Fish, when completing a flag with an = (e.g., <program> -n=<TAB>)
+# completions must be prefixed with the flag
+set -l flagPrefix (string match -r -- '-.*=' "$lastArg")
+
+__cli_debug "Comps: $comps"
+__cli_debug "DirectiveLine: $directiveLine"
+__cli_debug "flagPrefix: $flagPrefix"
+
+for comp in $comps
+  printf "%s%s
+" "$flagPrefix" "$comp"
+end
+
+printf "%s
+" "$directiveLine"
+end
+
+# This function limits calls to __cli_perform_completion, by caching the result
+function __cli_perform_completion_once
+__cli_debug "Starting __cli_perform_completion_once"
+
+if test -n "$__cli_perform_completion_once_result"
+  __cli_debug "Seems like a valid result already exists, skipping __cli_perform_completion"
+  return 0
+end
+
+set --global __cli_perform_completion_once_result (__cli_perform_completion)
+if test -z "$__cli_perform_completion_once_result"
+  __cli_debug "No completions, probably due to a failure"
+  return 1
+end
+
+__cli_debug "Performed completions and set __cli_perform_completion_once_result"
+return 0
+end
+
+# This function is used to clear the cached result after completions are run
+function __cli_clear_perform_completion_once_result
+__cli_debug ""
+__cli_debug "========= clearing previously set __cli_perform_completion_once_result variable =========="
+set --erase __cli_perform_completion_once_result
+__cli_debug "Successfully erased the variable __cli_perform_completion_once_result"
+end
+
+function __cli_requires_order_preservation
+__cli_debug ""
+__cli_debug "========= checking if order preservation is required =========="
+
+__cli_perform_completion_once
+if test -z "$__cli_perform_completion_once_result"
+  __cli_debug "Error determining if order preservation is required"
+  return 1
+end
+
+set -l directive (string sub --start 2 $__cli_perform_completion_once_result[-1])
+__cli_debug "Directive is: $directive"
+
+set -l shellCompDirectiveKeepOrder 32
+set -l keeporder (math (math --scale 0 $directive / $shellCompDirectiveKeepOrder) % 2)
+__cli_debug "Keeporder is: $keeporder"
+
+if test $keeporder -ne 0
+  __cli_debug "This does require order preservation"
+  return 0
+end
+
+__cli_debug "This doesn't require order preservation"
+return 1
+end
+
+# This function does two things:
+# - Obtain the completions and store them in the global __cli_comp_results
+# - Return false if file completion should be performed
+function __cli_prepare_completions
+__cli_debug ""
+__cli_debug "========= starting completion logic =========="
+
+# Start fresh
+set --erase __cli_comp_results
+
+__cli_perform_completion_once
+__cli_debug "Completion results: $__cli_perform_completion_once_result"
+
+if test -z "$__cli_perform_completion_once_result"
+  __cli_debug "No completion, probably due to a failure"
+  # Might as well do file completion, in case it helps
+  return 1
+end
+
+set -l directive (string sub --start 2 $__cli_perform_completion_once_result[-1])
+set --global __cli_comp_results $__cli_perform_completion_once_result[1..-2]
+
+__cli_debug "Completions are: $__cli_comp_results"
+__cli_debug "Directive is: $directive"
+
+set -l shellCompDirectiveError 1
+set -l shellCompDirectiveNoSpace 2
+set -l shellCompDirectiveNoFileComp 4
+set -l shellCompDirectiveFilterFileExt 8
+set -l shellCompDirectiveFilterDirs 16
+if test -z "$directive"
+  set directive 0
+end
+
+set -l compErr (math (math --scale 0 $directive / $shellCompDirectiveError) % 2)
+if test $compErr -eq 1
+  __cli_debug "Received error directive: aborting."
+  # Might as well do file completion, in case it helps
+  return 1
+end
+
+set -l filefilter (math (math --scale 0 $directive / $shellCompDirectiveFilterFileExt) % 2)
+set -l dirfilter (math (math --scale 0 $directive / $shellCompDirectiveFilterDirs) % 2)
+if test $filefilter -eq 1; or test $dirfilter -eq 1
+  __cli_debug "File extension filtering or directory filtering not supported"
+  # Do full file completion instead
+  return 1
+end
+
+set -l nospace (math (math --scale 0 $directive / $shellCompDirectiveNoSpace) % 2)
+set -l nofiles (math (math --scale 0 $directive / $shellCompDirectiveNoFileComp) % 2)
+
+__cli_debug "nospace: $nospace, nofiles: $nofiles"
+
+# If we want to prevent a space, or if file completion is NOT disabled,
+# we need to count the number of valid completions.
+# To do so, we will filter on prefix as the completions we have received
+# may not already be filtered so as to allow fish to match on different
+# criteria than the prefix.
+if test $nospace -ne 0; or test $nofiles -eq 0
+  set -l prefix (commandline -t | string escape --style=regex)
+  __cli_debug "prefix: $prefix"
+
+  set -l completions (string match -r -- "^$prefix.*" $__cli_comp_results)
+  set --global __cli_comp_results $completions
+  __cli_debug "Filtered completions are: $__cli_comp_results"
+
+  # Important not to quote the variable for count to work
+  set -l numComps (count $__cli_comp_results)
+  __cli_debug "numComps: $numComps"
+
+  if test $numComps -eq 1; and test $nospace -ne 0
+    # We must first split on 	 to get rid of the descriptions to be
+    # able to check what the actual completion will be.
+    # We don't need descriptions anyway since there is only a single
+    # real completion which the shell will expand immediately.
+    set -l split (string split --max 1 "	" $__cli_comp_results[1])
+
+    # Fish won't add a space if the completion ends with any
+    # of the following characters: @=/:.,
+    set -l lastChar (string sub -s -1 -- $split)
+    if not string match -r -q "[@=/:.,]" -- "$lastChar"
+      # In other cases, to support the "nospace" directive we trick the shell
+      # by outputting an extra, longer completion.
+      __cli_debug "Adding second completion to perform nospace directive"
+      set --global __cli_comp_results $split[1] $split[1].
+      __cli_debug "Completions are now: $__cli_comp_results"
+    end
+  end
+
+  if test $numComps -eq 0; and test $nofiles -eq 0
+    # To be consistent with bash and zsh, we only trigger file
+    # completion when there are no other completions
+    __cli_debug "Requesting file completion"
+    return 1
+  end
+end
+
+return 0
+end
+
+# Since Fish completions are only loaded once the user triggers them, we trigger them ourselves
+# so we can properly delete any completions provided by another script.
+# Only do this if the program can be found, or else fish may print some errors; besides,
+# the existing completions will only be loaded if the program can be found.
+if type -q "cli"
+# The space after the program name is essential to trigger completion for the program
+# and not completion of the program name itself.
+# Also, we use '> /dev/null 2>&1' since '&>' is not supported in older versions of fish.
+complete --do-complete "cli " > /dev/null 2>&1
+end
+
+# Remove any pre-existing completions for the program since we will be handling all of them.
+complete -c cli -e
+# This will get called after the two calls below and clear the cached result
+complete -c cli -n '__cli_clear_perform_completion_once_result'
+# The call to __cli_prepare_completions will setup __cli_comp_results
+# which provides the program's completion choices.
+# If this doesn't require order preservation, we don't use the -k flag
+complete -c cli -n 'not __cli_requires_order_preservation && __cli_prepare_completions' -f -a '$__cli_comp_results'
+# Otherwise we use the -k flag
+complete -k -c cli -n '__cli_requires_order_preservation && __cli_prepare_completions' -f -a '$__cli_comp_results'
+`,p=f.split(`
+`).map(f=>f.trim()?f.trim().startsWith(`#`)?`${a(f)}`:s(f).replaceAll(/(?<=\$(\{|\()).*(?=(\}\)))/g,l(`$&`)).replaceAll(/(\"|\').*(\"|\')/g,i(`$&`)).replaceAll(/(\[|\]|\(|\)|\||<|>|\$\(|\$?\{|\}|\+|=|;|:)/g,n(u(`$&`))).replaceAll(/(function|complete)\s+/g,l(`$&`)).replaceAll(/(?<=(function|complete)\s+)\w/g,n(o(`$&`))).replaceAll(/set\s+/g,t(`$&`)).replaceAll(/(?<=set\s+)\w/g,n(e(`$&`))).replaceAll(/while\s+/g,i(`$&`)).replaceAll(/(?<=while\s+)\w/g,n(c(`$&`))).replaceAll(/(if|fi|else|elif|then|done)\s+/g,l(`$&`)).replaceAll(/\s__\w/g,n(d(`$&`))).replaceAll(/(?<=\s)(-\w|--\w[\w-]*)(?=\s|$)/g,n(r(`$&`))):``).join(`
+`);export{p as n,f as t};

package/bin/shared-CLQvIZ7z.mjs

@@ -0,0 +1,216 @@
+import{C as e,S as t,a as n,b as r,c as i,d as a,h as o,j as s,l as c,m as l,p as u,x as d}from"./prompts-BnlPjHFR.mjs";const f=`__cli_debug() {
+local file="$BASH_COMP_DEBUG_FILE"
+if [[ -n \${file} ]]; then
+  echo "$*" >> "\${file}"
+fi
+}
+
+_cli() {
+local shellCompDirectiveError=1
+local shellCompDirectiveNoSpace=2
+local shellCompDirectiveNoFileComp=4
+local shellCompDirectiveFilterFileExt=8
+local shellCompDirectiveFilterDirs=16
+local shellCompDirectiveKeepOrder=32
+
+local lastParam lastChar flagPrefix requestComp out directive comp lastComp noSpace keepOrder
+local -a completions
+
+__cli_debug "
+========= starting completion logic =========="
+__cli_debug "CURRENT: \${CURRENT}, words[*]: \${words[*]}"
+
+# The user could have moved the cursor backwards on the command-line.
+# We need to trigger completion from the $CURRENT location, so we need
+# to truncate the command-line ($words) up to the $CURRENT location.
+# (We cannot use $CURSOR as its value does not work when a command is an alias.)
+words=( "\${=words[1,CURRENT]}" )
+__cli_debug "Truncated words[*]: \${words[*]},"
+
+lastParam=\${words[-1]}
+lastChar=\${lastParam[-1]}
+__cli_debug "lastParam: \${lastParam}, lastChar: \${lastChar}"
+# For zsh, when completing a flag with an = (e.g., cli -n=<TAB>)
+# completions must be prefixed with the flag
+setopt local_options BASH_REMATCH
+if [[ "\${lastParam}" =~ '-.*=' ]]; then
+  # We are dealing with a flag with an =
+  flagPrefix="-P \${BASH_REMATCH}"
+fi
+
+# Prepare the command to obtain completions, ensuring arguments are quoted for eval
+local -a args_to_quote=("\${(@)words[2,-1]}")
+if [ "\${lastChar}" = "" ]; then
+  # If the last parameter is complete (there is a space following it)
+  # We add an extra empty parameter so we can indicate this to the go completion code.
+  __cli_debug "Adding extra empty parameter"
+  args_to_quote+=("")
+fi
+
+# Use Zsh's (q) flag to quote each argument safely for eval
+local quoted_args=("\${(@q)args_to_quote}")
+
+# Join the main command and the quoted arguments into a single string for eval
+requestComp="/nix/store/8spcnffxayf4h9v8w075j01bxxgv5c8j-nodejs-slim-26.3.0/bin/node  /home/runner/work/powerlines/powerlines/node_modules/.pnpm/nx@22.7.5_@swc-node+register@1.11.1_@swc+core@1.15.40_@swc+helpers@0.5.23__@swc+types@0_559e3db9ab82faa3b71ca2061041f3f6/node_modules/nx/dist/bin/run-executor.js complete -- \${quoted_args[*]}"
+
+__cli_debug "About to call: eval \${requestComp}"
+
+# Use eval to handle any environment variables and such
+out=$(eval \${requestComp} 2>/dev/null)
+__cli_debug "completion output: \${out}"
+
+# Extract the directive integer following a : from the last line
+local lastLine
+while IFS='
+' read -r line; do
+lastLine=\${line}
+done < <(printf "%s
+" "\${out[@]}")
+__cli_debug "last line: \${lastLine}"
+
+if [ "\${lastLine[1]}" = : ]; then
+  directive=\${lastLine[2,-1]}
+  # Remove the directive including the : and the newline
+  local suffix
+  (( suffix=\${#lastLine}+2))
+  out=\${out[1,-$suffix]}
+else
+  # There is no directive specified.  Leave $out as is.
+  __cli_debug "No directive found.  Setting to default"
+  directive=0
+fi
+
+__cli_debug "directive: \${directive}"
+__cli_debug "completions: \${out}"
+__cli_debug "flagPrefix: \${flagPrefix}"
+
+if [ $((directive & shellCompDirectiveError)) -ne 0 ]; then
+  __cli_debug "Completion received error. Ignoring completions."
+  return
+fi
+
+local activeHelpMarker="%"
+local endIndex=\${#activeHelpMarker}
+local startIndex=$((\${#activeHelpMarker}+1))
+local hasActiveHelp=0
+while IFS='
+' read -r comp; do
+# Check if this is an activeHelp statement (i.e., prefixed with $activeHelpMarker)
+if [ "\${comp[1,$endIndex]}" = "$activeHelpMarker" ];then
+  __cli_debug "ActiveHelp found: $comp"
+  comp="\${comp[$startIndex,-1]}"
+  if [ -n "$comp" ]; then
+    compadd -x "\${comp}"
+    __cli_debug "ActiveHelp will need delimiter"
+    hasActiveHelp=1
+  fi
+  continue
+fi
+
+if [ -n "$comp" ]; then
+  # If requested, completions are returned with a description.
+  # The description is preceded by a TAB character.
+  # For zsh's _describe, we need to use a : instead of a TAB.
+  # We first need to escape any : as part of the completion itself.
+  comp=\${comp//:/:}
+
+  local tab="$(printf '	')"
+  comp=\${comp//$tab/:}
+
+  __cli_debug "Adding completion: \${comp}"
+  completions+=\${comp}
+  lastComp=$comp
+fi
+done < <(printf "%s
+" "\${out[@]}")
+
+# Add a delimiter after the activeHelp statements, but only if:
+# - there are completions following the activeHelp statements, or
+# - file completion will be performed (so there will be choices after the activeHelp)
+if [ $hasActiveHelp -eq 1 ]; then
+  if [ \${#completions} -ne 0 ] || [ $((directive & shellCompDirectiveNoFileComp)) -eq 0 ]; then
+    __cli_debug "Adding activeHelp delimiter"
+    compadd -x "--"
+    hasActiveHelp=0
+  fi
+fi
+
+if [ $((directive & shellCompDirectiveNoSpace)) -ne 0 ]; then
+  __cli_debug "Activating nospace."
+  noSpace="-S ''"
+fi
+
+if [ $((directive & shellCompDirectiveKeepOrder)) -ne 0 ]; then
+  __cli_debug "Activating keep order."
+  keepOrder="-V"
+fi
+
+if [ $((directive & shellCompDirectiveFilterFileExt)) -ne 0 ]; then
+  # File extension filtering
+  local filteringCmd
+  filteringCmd='_files'
+  for filter in \${completions[@]}; do
+    if [ \${filter[1]} != '*' ]; then
+      # zsh requires a glob pattern to do file filtering
+      filter="*.$filter"
+    fi
+    filteringCmd+=" -g $filter"
+  done
+  filteringCmd+=" \${flagPrefix}"
+
+  __cli_debug "File filtering command: $filteringCmd"
+  _arguments '*:filename:'"$filteringCmd"
+elif [ $((directive & shellCompDirectiveFilterDirs)) -ne 0 ]; then
+  # File completion for directories only
+  local subdir
+  subdir="\${completions[1]}"
+  if [ -n "$subdir" ]; then
+    __cli_debug "Listing directories in $subdir"
+    pushd "\${subdir}" >/dev/null 2>&1
+  else
+    __cli_debug "Listing directories in ."
+  fi
+
+  local result
+  _arguments '*:dirname:_files -/'" \${flagPrefix}"
+  result=$?
+  if [ -n "$subdir" ]; then
+    popd >/dev/null 2>&1
+  fi
+  return $result
+else
+  __cli_debug "Calling _describe"
+  if eval _describe $keepOrder "completions" completions -Q \${flagPrefix} \${noSpace}; then
+    __cli_debug "_describe found some completions"
+
+    # Return the success of having called _describe
+    return 0
+  else
+    __cli_debug "_describe did not find completions."
+    __cli_debug "Checking if we should do file completion."
+    if [ $((directive & shellCompDirectiveNoFileComp)) -ne 0 ]; then
+      __cli_debug "deactivating file completion"
+
+      # Return 0 to indicate completion is finished and prevent zsh from
+      # trying other completion algorithms (which could cause hanging).
+      # We use NoFileComp directive to explicitly disable file completion.
+      return 0
+    else
+      # Perform file completion
+      __cli_debug "Activating file completion"
+
+      # We must return the result of this command, so it must be the
+      # last command, or else we must store its result to return it.
+      _arguments '*:filename:_files'" \${flagPrefix}"
+    fi
+  fi
+fi
+}
+
+# don't run the completion function when being sourced or eval-ed
+if [ "\${funcstack[1]}" = "_cli" ]; then
+_cli
+fi
+`,p=f.split(`
+`).map(f=>f.trim()?f.trim().startsWith(`#`)?`${a(f)}`:s(f).replaceAll(/(?<=\$(\{|\()).*(?=(\}\)))/g,l(`$&`)).replaceAll(/\".*\"/g,i(`$&`)).replaceAll(/(\[|\]|\(|\)|\||<|>|\$\(|\$?\{|\}|\+|=|;|:)/g,n(u(`$&`))).replaceAll(/(readonly|complete)\s+/g,l(`$&`)).replaceAll(/(?<=(readonly|complete)\s+)\w/g,n(o(`$&`))).replaceAll(/local\s+/g,t(`$&`)).replaceAll(/(?<=local\s+)\w/g,n(e(`$&`))).replaceAll(/(for|while)\s+/g,i(`$&`)).replaceAll(/(?<=for|while\s+)\w/g,n(c(`$&`))).replaceAll(/(return|if|fi|else|elif|then|done)\s+/g,l(`$&`)).replaceAll(/__\w/g,n(d(`$&`))).replaceAll(/(?<=\s)(-\w|--\w[\w-]*)(?=\s|$)/g,n(r(`$&`))):``).join(`
+`);export{p as n,f as t};