@shell-shock/plugin-completions 0.4.16 → 0.4.18

package/dist/components/fish-shared.cjs

@@ -1,25 +1,73 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`../helpers/complete-command.cjs`),t=require(`../helpers/completion-directive-constants.cjs`);require(`../helpers/index.cjs`);let n=require(`@alloy-js/core/jsx-runtime`),r=require(`@shell-shock/core/plugin-utils`),i=require(`@alloy-js/core`),a=require(`@alloy-js/typescript`),o=require(`@powerlines/plugin-alloy/core`),s=require(`@powerlines/plugin-alloy/core/contexts/context`),c=require(`@powerlines/plugin-alloy/typescript`),l=require(`@stryke/path`),u=require(`@stryke/string-format/snake-case`);function d(){let d=(0,s.usePowerlines)(),f=(0,i.computed)(()=>(0,r.getAppBin)(d)),p=(0,i.computed)(()=>(0,u.snakeCase)(f.value));return(0,n.createComponent)(c.TypescriptFile,{get path(){return(0,l.joinPaths)(d.entryPath,`completions`,`fish`,`shared.ts`)},builtinImports:{console:[`white`,`green`,`red`,`bold`,`cyan`,`gray`,`magenta`,`magentaBright`,`greenBright`,`redBright`,`cyanBright`,`dim`]},get children(){return[(0,n.createComponent)(o.Spacing,{}),(0,n.createComponent)(a.VarDeclaration,{const:!0,export:!0,name:`SHELL_COMPLETIONS`,get initializer(){return i.code` \`function __${p.value}_debug
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_helpers_complete_command = require('../helpers/complete-command.cjs');
+const require_helpers_completion_directive_constants = require('../helpers/completion-directive-constants.cjs');
+require('../helpers/index.cjs');
+let _alloy_js_core_jsx_runtime = require("@alloy-js/core/jsx-runtime");
+let _shell_shock_core_plugin_utils = require("@shell-shock/core/plugin-utils");
+let _alloy_js_core = require("@alloy-js/core");
+let _alloy_js_typescript = require("@alloy-js/typescript");
+let _powerlines_plugin_alloy_core = require("@powerlines/plugin-alloy/core");
+let _powerlines_plugin_alloy_core_contexts_context = require("@powerlines/plugin-alloy/core/contexts/context");
+let _powerlines_plugin_alloy_typescript = require("@powerlines/plugin-alloy/typescript");
+let _stryke_path = require("@stryke/path");
+let _stryke_string_format_snake_case = require("@stryke/string-format/snake-case");
+
+//#region src/components/fish-shared.tsx
+/**
+* The Fish Completions generation for the Shell Shock project.
+*/
+function FishCompletionsShared() {
+	const context = (0, _powerlines_plugin_alloy_core_contexts_context.usePowerlines)();
+	const bin = (0, _alloy_js_core.computed)(() => (0, _shell_shock_core_plugin_utils.getAppBin)(context));
+	const name = (0, _alloy_js_core.computed)(() => (0, _stryke_string_format_snake_case.snakeCase)(bin.value));
+	return (0, _alloy_js_core_jsx_runtime.createComponent)(_powerlines_plugin_alloy_typescript.TypescriptFile, {
+		get path() {
+			return (0, _stryke_path.joinPaths)(context.entryPath, "completions", "fish", "shared.ts");
+		},
+		builtinImports: { console: [
+			"white",
+			"green",
+			"red",
+			"bold",
+			"cyan",
+			"gray",
+			"magenta",
+			"magentaBright",
+			"greenBright",
+			"redBright",
+			"cyanBright",
+			"dim"
+		] },
+		get children() {
+			return [
+				(0, _alloy_js_core_jsx_runtime.createComponent)(_powerlines_plugin_alloy_core.Spacing, {}),
+				(0, _alloy_js_core_jsx_runtime.createComponent)(_alloy_js_typescript.VarDeclaration, {
+					"const": true,
+					"export": true,
+					name: "SHELL_COMPLETIONS",
+					get initializer() {
+						return _alloy_js_core.code` \`function __${name.value}_debug
     set -l file "$BASH_COMP_DEBUG_FILE"
     if test -n "$file"
         echo "$argv" >> $file
     end
 end
 
-function __${p.value}_perform_completion
-    __${p.value}_debug "Starting __${p.value}_perform_completion"
+function __${name.value}_perform_completion
+    __${name.value}_debug "Starting __${name.value}_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))
 
-    __${p.value}_debug "args: $args"
-    __${p.value}_debug "last arg: $lastArg"
+    __${name.value}_debug "args: $args"
+    __${name.value}_debug "last arg: $lastArg"
 
     # Build the completion request command
-    set -l requestComp "${e.EXEC_COMMAND} complete -- (string join ' ' -- (string escape -- $args[2..-1])) $lastArg"
+    set -l requestComp "${require_helpers_complete_command.EXEC_COMMAND} complete -- (string join ' ' -- (string escape -- $args[2..-1])) $lastArg"
 
-    __${p.value}_debug "Calling $requestComp"
+    __${name.value}_debug "Calling $requestComp"
     set -l results (eval $requestComp 2> /dev/null)
 
     # Some programs may output extra empty lines after the directive.
@@ -42,9 +90,9 @@ function __${p.value}_perform_completion
     # completions must be prefixed with the flag
     set -l flagPrefix (string match -r -- '-.*=' "$lastArg")
 
-    __${p.value}_debug "Comps: $comps"
-    __${p.value}_debug "DirectiveLine: $directiveLine"
-    __${p.value}_debug "flagPrefix: $flagPrefix"
+    __${name.value}_debug "Comps: $comps"
+    __${name.value}_debug "DirectiveLine: $directiveLine"
+    __${name.value}_debug "flagPrefix: $flagPrefix"
 
     for comp in $comps
         printf "%s%s\\n" "$flagPrefix" "$comp"
@@ -53,96 +101,96 @@ function __${p.value}_perform_completion
     printf "%s\\n" "$directiveLine"
 end
 
-# This function limits calls to __${p.value}_perform_completion, by caching the result
-function __${p.value}_perform_completion_once
-    __${p.value}_debug "Starting __${p.value}_perform_completion_once"
+# This function limits calls to __${name.value}_perform_completion, by caching the result
+function __${name.value}_perform_completion_once
+    __${name.value}_debug "Starting __${name.value}_perform_completion_once"
 
-    if test -n "$__${p.value}_perform_completion_once_result"
-        __${p.value}_debug "Seems like a valid result already exists, skipping __${p.value}_perform_completion"
+    if test -n "$__${name.value}_perform_completion_once_result"
+        __${name.value}_debug "Seems like a valid result already exists, skipping __${name.value}_perform_completion"
         return 0
     end
 
-    set --global __${p.value}_perform_completion_once_result (__${p.value}_perform_completion)
-    if test -z "$__${p.value}_perform_completion_once_result"
-        __${p.value}_debug "No completions, probably due to a failure"
+    set --global __${name.value}_perform_completion_once_result (__${name.value}_perform_completion)
+    if test -z "$__${name.value}_perform_completion_once_result"
+        __${name.value}_debug "No completions, probably due to a failure"
         return 1
     end
 
-    __${p.value}_debug "Performed completions and set __${p.value}_perform_completion_once_result"
+    __${name.value}_debug "Performed completions and set __${name.value}_perform_completion_once_result"
     return 0
 end
 
 # This function is used to clear the cached result after completions are run
-function __${p.value}_clear_perform_completion_once_result
-    __${p.value}_debug ""
-    __${p.value}_debug "========= clearing previously set __${p.value}_perform_completion_once_result variable =========="
-    set --erase __${p.value}_perform_completion_once_result
-    __${p.value}_debug "Successfully erased the variable __${p.value}_perform_completion_once_result"
+function __${name.value}_clear_perform_completion_once_result
+    __${name.value}_debug ""
+    __${name.value}_debug "========= clearing previously set __${name.value}_perform_completion_once_result variable =========="
+    set --erase __${name.value}_perform_completion_once_result
+    __${name.value}_debug "Successfully erased the variable __${name.value}_perform_completion_once_result"
 end
 
-function __${p.value}_requires_order_preservation
-    __${p.value}_debug ""
-    __${p.value}_debug "========= checking if order preservation is required =========="
+function __${name.value}_requires_order_preservation
+    __${name.value}_debug ""
+    __${name.value}_debug "========= checking if order preservation is required =========="
 
-    __${p.value}_perform_completion_once
-    if test -z "$__${p.value}_perform_completion_once_result"
-        __${p.value}_debug "Error determining if order preservation is required"
+    __${name.value}_perform_completion_once
+    if test -z "$__${name.value}_perform_completion_once_result"
+        __${name.value}_debug "Error determining if order preservation is required"
         return 1
     end
 
-    set -l directive (string sub --start 2 $__${p.value}_perform_completion_once_result[-1])
-    __${p.value}_debug "Directive is: $directive"
+    set -l directive (string sub --start 2 $__${name.value}_perform_completion_once_result[-1])
+    __${name.value}_debug "Directive is: $directive"
 
-    set -l shellCompDirectiveKeepOrder ${t.CompletionDirective.CompletionDirectiveKeepOrder}
+    set -l shellCompDirectiveKeepOrder ${require_helpers_completion_directive_constants.CompletionDirective.CompletionDirectiveKeepOrder}
     set -l keeporder (math (math --scale 0 $directive / $shellCompDirectiveKeepOrder) % 2)
-    __${p.value}_debug "Keeporder is: $keeporder"
+    __${name.value}_debug "Keeporder is: $keeporder"
 
     if test $keeporder -ne 0
-        __${p.value}_debug "This does require order preservation"
+        __${name.value}_debug "This does require order preservation"
         return 0
     end
 
-    __${p.value}_debug "This doesn't require order preservation"
+    __${name.value}_debug "This doesn't require order preservation"
     return 1
 end
 
 # This function does two things:
-# - Obtain the completions and store them in the global __${p.value}_comp_results
+# - Obtain the completions and store them in the global __${name.value}_comp_results
 # - Return false if file completion should be performed
-function __${p.value}_prepare_completions
-    __${p.value}_debug ""
-    __${p.value}_debug "========= starting completion logic =========="
+function __${name.value}_prepare_completions
+    __${name.value}_debug ""
+    __${name.value}_debug "========= starting completion logic =========="
 
     # Start fresh
-    set --erase __${p.value}_comp_results
+    set --erase __${name.value}_comp_results
 
-    __${p.value}_perform_completion_once
-    __${p.value}_debug "Completion results: $__${p.value}_perform_completion_once_result"
+    __${name.value}_perform_completion_once
+    __${name.value}_debug "Completion results: $__${name.value}_perform_completion_once_result"
 
-    if test -z "$__${p.value}_perform_completion_once_result"
-        __${p.value}_debug "No completion, probably due to a failure"
+    if test -z "$__${name.value}_perform_completion_once_result"
+        __${name.value}_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 $__${p.value}_perform_completion_once_result[-1])
-    set --global __${p.value}_comp_results $__${p.value}_perform_completion_once_result[1..-2]
+    set -l directive (string sub --start 2 $__${name.value}_perform_completion_once_result[-1])
+    set --global __${name.value}_comp_results $__${name.value}_perform_completion_once_result[1..-2]
 
-    __${p.value}_debug "Completions are: $__${p.value}_comp_results"
-    __${p.value}_debug "Directive is: $directive"
+    __${name.value}_debug "Completions are: $__${name.value}_comp_results"
+    __${name.value}_debug "Directive is: $directive"
 
-    set -l shellCompDirectiveError ${t.CompletionDirective.CompletionDirectiveError}
-    set -l shellCompDirectiveNoSpace ${t.CompletionDirective.CompletionDirectiveNoSpace}
-    set -l shellCompDirectiveNoFileComp ${t.CompletionDirective.CompletionDirectiveNoFileComp}
-    set -l shellCompDirectiveFilterFileExt ${t.CompletionDirective.CompletionDirectiveFilterFileExt}
-    set -l shellCompDirectiveFilterDirs ${t.CompletionDirective.CompletionDirectiveFilterDirs}
+    set -l shellCompDirectiveError ${require_helpers_completion_directive_constants.CompletionDirective.CompletionDirectiveError}
+    set -l shellCompDirectiveNoSpace ${require_helpers_completion_directive_constants.CompletionDirective.CompletionDirectiveNoSpace}
+    set -l shellCompDirectiveNoFileComp ${require_helpers_completion_directive_constants.CompletionDirective.CompletionDirectiveNoFileComp}
+    set -l shellCompDirectiveFilterFileExt ${require_helpers_completion_directive_constants.CompletionDirective.CompletionDirectiveFilterFileExt}
+    set -l shellCompDirectiveFilterDirs ${require_helpers_completion_directive_constants.CompletionDirective.CompletionDirectiveFilterDirs}
     if test -z "$directive"
         set directive 0
     end
 
     set -l compErr (math (math --scale 0 $directive / $shellCompDirectiveError) % 2)
     if test $compErr -eq 1
-        __${p.value}_debug "Received error directive: aborting."
+        __${name.value}_debug "Received error directive: aborting."
         # Might as well do file completion, in case it helps
         return 1
     end
@@ -150,7 +198,7 @@ function __${p.value}_prepare_completions
     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
-        __${p.value}_debug "File extension filtering or directory filtering not supported"
+        __${name.value}_debug "File extension filtering or directory filtering not supported"
         # Do full file completion instead
         return 1
     end
@@ -158,7 +206,7 @@ function __${p.value}_prepare_completions
     set -l nospace (math (math --scale 0 $directive / $shellCompDirectiveNoSpace) % 2)
     set -l nofiles (math (math --scale 0 $directive / $shellCompDirectiveNoFileComp) % 2)
 
-    __${p.value}_debug "nospace: $nospace, nofiles: $nofiles"
+    __${name.value}_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.
@@ -167,22 +215,22 @@ function __${p.value}_prepare_completions
     # criteria than the prefix.
     if test $nospace -ne 0; or test $nofiles -eq 0
         set -l prefix (commandline -t | string escape --style=regex)
-        __${p.value}_debug "prefix: $prefix"
+        __${name.value}_debug "prefix: $prefix"
 
-        set -l completions (string match -r -- "^$prefix.*" $__${p.value}_comp_results)
-        set --global __${p.value}_comp_results $completions
-        __${p.value}_debug "Filtered completions are: $__${p.value}_comp_results"
+        set -l completions (string match -r -- "^$prefix.*" $__${name.value}_comp_results)
+        set --global __${name.value}_comp_results $completions
+        __${name.value}_debug "Filtered completions are: $__${name.value}_comp_results"
 
         # Important not to quote the variable for count to work
-        set -l numComps (count $__${p.value}_comp_results)
-        __${p.value}_debug "numComps: $numComps"
+        set -l numComps (count $__${name.value}_comp_results)
+        __${name.value}_debug "numComps: $numComps"
 
         if test $numComps -eq 1; and test $nospace -ne 0
             # We must first split on \\t 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 "\\t" $__${p.value}_comp_results[1])
+            set -l split (string split --max 1 "\\t" $__${name.value}_comp_results[1])
 
             # Fish won't add a space if the completion ends with any
             # of the following characters: @=/:.,
@@ -190,16 +238,16 @@ function __${p.value}_prepare_completions
             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.
-                __${p.value}_debug "Adding second completion to perform nospace directive"
-                set --global __${p.value}_comp_results $split[1] $split[1].
-                __${p.value}_debug "Completions are now: $__${p.value}_comp_results"
+                __${name.value}_debug "Adding second completion to perform nospace directive"
+                set --global __${name.value}_comp_results $split[1] $split[1].
+                __${name.value}_debug "Completions are now: $__${name.value}_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
-            __${p.value}_debug "Requesting file completion"
+            __${name.value}_debug "Requesting file completion"
             return 1
         end
     end
@@ -211,24 +259,32 @@ end
 # 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 "${f.value}"
+if type -q "${bin.value}"
     # 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 "${f.value} " > /dev/null 2>&1
+    complete --do-complete "${bin.value} " > /dev/null 2>&1
 end
 
 # Remove any pre-existing completions for the program since we will be handling all of them.
-complete -c ${f.value} -e
+complete -c ${bin.value} -e
 # This will get called after the two calls below and clear the cached result
-complete -c ${f.value} -n '__${p.value}_clear_perform_completion_once_result'
-# The call to __${p.value}_prepare_completions will setup __${p.value}_comp_results
+complete -c ${bin.value} -n '__${name.value}_clear_perform_completion_once_result'
+# The call to __${name.value}_prepare_completions will setup __${name.value}_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 ${(0,r.getAppBin)(d)} -n 'not __${p.value}_requires_order_preservation && __${p.value}_prepare_completions' -f -a '$__${p.value}_comp_results'
+complete -c ${(0, _shell_shock_core_plugin_utils.getAppBin)(context)} -n 'not __${name.value}_requires_order_preservation && __${name.value}_prepare_completions' -f -a '$__${name.value}_comp_results'
 # Otherwise we use the -k flag
-complete -k -c ${f.value} -n '__${p.value}_requires_order_preservation && __${p.value}_prepare_completions' -f -a '$__${p.value}_comp_results'
-\`; `}}),(0,n.createComponent)(o.Spacing,{}),(0,n.createComponent)(a.VarDeclaration,{export:!0,const:!0,name:`SHELL_COMPLETIONS_DISPLAY`,initializer:i.code` SHELL_COMPLETIONS.split("\\n").map(line => {
+complete -k -c ${bin.value} -n '__${name.value}_requires_order_preservation && __${name.value}_prepare_completions' -f -a '$__${name.value}_comp_results'
+\`; `;
+					}
+				}),
+				(0, _alloy_js_core_jsx_runtime.createComponent)(_powerlines_plugin_alloy_core.Spacing, {}),
+				(0, _alloy_js_core_jsx_runtime.createComponent)(_alloy_js_typescript.VarDeclaration, {
+					"export": true,
+					"const": true,
+					name: "SHELL_COMPLETIONS_DISPLAY",
+					initializer: _alloy_js_core.code` SHELL_COMPLETIONS.split("\\n").map(line => {
           if (!line.trim()) {
             return "";
           }
@@ -249,4 +305,12 @@ complete -k -c ${f.value} -n '__${p.value}_requires_order_preservation && __${p.
             .replaceAll(/\\s__\\w/g, bold(magentaBright("$&")))
             .replaceAll(/(?<=\\s)(-\\w|--\\w[\\w-]*)(?=\\s|$)/g, bold(magenta("$&")));
 
-        }).join("\\n"); `})]}})}exports.FishCompletionsShared=d;
+        }).join("\\n"); `
+				})
+			];
+		}
+	});
+}
+
+//#endregion
+exports.FishCompletionsShared = FishCompletionsShared;