05AB1E, 5 bytes

ΣêR}R

Try it online!
or as a Test suite

Explanation

Σ  }    # sort input by

 ê      # its sorted unique characters

  R     # reversed (to sort descending)

    R   # reverse the result (to sort descending)

R, 97 95 bytes

function(x)x[rev(order(sapply(Map(sort,Map(unique,strsplit(paste(x),"")),T),Reduce,f=paste0)))]

Try it online!

This challenge seems to have been pessimized for R. Explanation of the original version (start at 1. and work up):

f <- function(x) {

  x[                                                  # 8. Input vector in

    rev(                                              # 7. Reversed

        order(                                        # 6. Lexicographical order

              sapply(                                 # 5. Paste....

                     Map(sort,                        # 4. Sort each using...

                              Map(unique,             # 3. Deduplicate each

                                  strsplit(           # 2. Split each string into characters

                                           paste(x),  # 1. Coerce each number to string

                                           "")),      

                         T),                          # 4. ...descending sort.

                     paste,collapse="")               # 5. ...back into strings

              )

        )

    ]

}

Perl 6, 36 34 33 31 bytes

-1 byte thanks to Jo King
-2 bytes thanks to Phil H

*.sort:{sort 1,|set -<<m:g/d/}

Try it online!

Explanation

       {                      }  # Map each number, e.g. -373

                       m:g/d/  # Extract digits: (3, 7, 3)

                    -<<  # Negate each digit: (-3, -7, -3)

                set  # Convert to set to remove duplicates

               |  # Pass as list of pairs: (-3 => True, -7 => True)

             1,  # Prepend 1 for "none": (1, -3 => True, -7 => True)

        sort  # Sort (compares 1 and pair by string value): (-7 => True, -3 => True, 1)

*.sort:  # Sort lexicographically

Python 2, 60 55 54 bytes

-1 byte thanks to Jonas Ausevicius.

def f(l):l.sort(cmp,lambda n:sorted(set(`n`))[::-1],1)

Try it online!

Ungolfed

def f(l):

  l.sort(        # Sort the list in place

    cmp = cmp,   # ... compare with the builtin function cmp

    key = k,     # ... on the function k

    reverse = 1  # ... in reverse

  )              # As the arguments are used in the right order, no names are necessary.



k = lambda n:sorted( # sort  

  set(`n`)           # ... the set of digits

  )[::-1]            # reverse the result

                     # As '-' is smaller than the digits,

                     # it will be sorted to the back and ignored for sorting

Try it online!

Python 2, 58 60 bytes

lambda a:sorted(a,key=lambda x:sorted(set(`x`))[::-1])[::-1]


Try it online!

Brachylog, 9 bytes

{ȧdṫo₁}ᵒ¹

Note: due to how ordering works in brachylog, it does not work on number correctly. This is fixed by casting the number to a string (ṫ) at the cost of 1 byte.

Try it online!

Pyth, 7 6 bytes

-1 byte by @Sok

_o_{S`

Pyth, which uses only printable ASCII, is at a bit of a disadvantage here. Optimally encoded this would be 6*log(95)/log(256) = 4.927 bytes, beating 05AB1E.

Explained:

 o              Sort the implicit input by lambda N:

  _               reversed

   {               uniquified

    S               sorted

     '               string representation [of N]

_               then reverse the result.

Try it here.

Jelly, 8 bytes

ADṢUQµÞU

Try it online!

How it works

ADṢUQµÞU  Main link (monad). Input: integer list

     µÞU  Sort by (reversed):

AD        Absolute value converted to decimal digits

  ṢUQ     Sort, reverse, take unique values

MathGolf, 7 6 bytes

áÉ░▀zx

Try it online! or as a test suite.

Explanation

After looking at Emigna's 05AB1E solution, I found that I didn't need the absolute operator (and my previous answer was actually incorrect because of that operator). Now the main difference is that I convert to string and get unique characters instead of using the 1-byte operator in 05AB1E.

áÉ      Sort by the value generated from mapping each element using the next 3 instructions

  ░     Convert to string

   ▀    Get unique characters

    z   Sort reversed (last instruction of block)

     x  Reverse list (needed because I don't have a sort-reversed by mapping)

C (gcc), 114 111 bytes

a;v(n){n=n<0?-n:n;for(a=0;n;n/=10)a|=1<<n%10;n=a;}c(int*a,int*b){a=v(*a)<v(*b);}f(a,n)int*a,n;{qsort(a,n,4,c);}

Try it online!

Explanation:

f() uses qsort() to sort provided array in place. Using comparison function c() to compare numbers which evaluates numbers using v().
v() calculates a higher number if bigger digits are present in parameter.

[Edit 1]
Improved by 3 bytes. 2 byte credits to Kevin. Thanks

Stax, 6 7 bytes

èó≥ü≤♥¥

Run and debug it

J, 17 bytes

{~[::~.@:~@":@|

Try it online!

Explanation:

                @|    - find the absolute value and

             @":      - convert to string and

         @:~         - sort down and

       ~.             - keep only the unique symbols

    :                - grade down the entire list of strings   

  [:                  - function composition

{~                    - use the graded-down list to index into the input   

JavaScript (SpiderMonkey), 68 bytes

Thanks for @Arnauld for reminding me again that SpiderMonkey uses stable sort, so -4 bytes for removing ||-1.

A=>A.sort((x,y,F=n=>[...new Set(""+n)].sort().reverse())=>F(x)<F(y))

Try it online!

JavaScript (Node.js), 72 bytes

A=>A.sort((x,y,F=n=>[...new Set(""+n)].sort().reverse())=>F(x)<F(y)||-1)

Try it online!

Java (JDK), 98 bytes

l->l.sort((a,b)->{int r=0,i=58;for(;r==0&i-->48;)r=(b.indexOf(i)>>9)-(a.indexOf(i)>>9);return r;})

Try it online!

Explanation

l->                           // Consumer<List<String>>

 l.sort(                      //  Use the incorporated sort method which uses a...

  (a,b)->{                    //   Comparator of Strings

   int r=0,                   //    define r as the result, initiated to 0

       i=58;                  //           i as the codepoint to test for.

   for(;r==0&i-->48;)         //    for each digit codepoint from '9' to '0',

                              //     and while no difference was found.

    r=                        //     set r as the difference between

     (b.indexOf(i)>>9)-       //      was the digit found in b? then 0 else -1 using the bit-shift operator

     (a.indexOf(i)>>9);       //      and was the digit found in a? then 0 else -1.

   return r;                  //    return the comparison result.

  }

 )

Note:

I needed a way to map numbers to either 0/1 or 0/-1.

indexOf has the nice property that it's consistently returning -1 for characters not found. -1 right-shifted by any number is always -1. Any positive number right-shifted by a big enough number will always produce 0.

So here we are:

input        input.indexOf('9')      input.indexOf('9')>>9

"999"        0                       0

"111119"     5                       0

"123456"     -1                      -1

Japt, 12 bytes

ñ_a ì â ñnÃw

All test cases

Explanation:

ñ_        Ãw    :Sort Descending by:

  a             : Get the absolute value

    ì           : Get the digits

      â         : Remove duplicates

        ñn      : Sort the digits in descending order

Haskell, 54 52 bytes

import Data.List

f=r.sortOn(r.sort.nub.show);r=reverse

Try it online!

APL (Dyalog Extended), 19 bytes

{⍵[⍒∪¨(∨'¯'~⍨⍕)¨⍵]}

Try it online!

Fixed at a cost of +2 bytes thanks to OP.

Ruby, 55 bytes

->a{a.sort_by{|x|x.abs.digits.sort.reverse|}.reverse}

Try it online!

Perl 5 -nl, 68 bytes

$a{eval"9876543210=~y/$_//dcr"}=$_}{say$a{$_}for reverse sort keys%a

Try it online!

Julia 1.0, 50 bytes

x->sort(x,by=y->sort(unique([digits(-abs(y));1])))

Try it online!

APL(NARS), 366 chars, 732 bytes

_gb←⍬



∇a _s w;t

t←_gb[a]⋄_gb[a]←_gb[w]⋄_gb[w]←t

∇



∇(_f _q)w;l;r;ls;i

(l r)←w⋄→0×⍳l≥r⋄l _s⌊2÷⍨l+r⋄ls←i←l⋄→3

  →3×⍳∼0<_gb[i]_f _gb[l]⋄ls+←1⋄ls _s i

  →2×⍳r≥i+←1

l _s ls⋄_f _q l(ls-1)⋄_f _q(ls+1)r

∇



∇r←(a qsort)w

r←¯1⋄→0×⍳1≠⍴⍴w⋄_gb←w⋄a _q 1(↑⍴w)⋄r←_gb

∇



f←{∪t[⍒t←⍎¨⍕∣⍵]}



∇r←a c b;x;y;i;m

x←f a⋄y←f b⋄r←i←0⋄m←(↑⍴x)⌊(↑⍴y)⋄→3

→0×⍳x[i]<y[i]⋄→3×⍳∼x[i]>y[i]⋄r←1⋄→0

→2×⍳m≥i+←1⋄r←(↑⍴x)>(↑⍴y)

∇

For the qsort operator, it is one traslation in APL of algo page 139 K&R Linguaggio C.
I think in it there is using data as C with pointers...
Test

 c qsort 123, 478, ¯904, 62778, 0, ¯73, 8491, 3120, 6458, ¯7738, 373 

8491 ¯904 62778 478 ¯7738 6458 ¯73 373 3120 123 0 

 c qsort 11, ¯312, 902, 23, 321, 2132, 34202, ¯34, ¯382 

902 ¯382 34202 ¯34 321 ¯312 2132 23 11 

 c qsort 9, 44, 2212, 4, 6, 6, 1, 2, 192, 21, 29384, 0 

29384 192 9 6 6 4 44 2212 21 2 1 0 

 c qsort 44, ¯88, 9, 233, ¯3, 14, 101, 77, 555, 67 

9 ¯88 67 77 555 14 44 233 ¯3 101 

Powershell, 44 bytes

$args|sort{$_-split'(.)'-ne'-'|sort -u -d}-d

Test script:

$f = {



$args|sort{$_-split'(.)'-ne'-'|sort -u -d}-d



}



@(

    ,( (123, 478, -904, 62778, 0, -73, 8491, 3120, 6458, -7738, 373),

       (8491, -904, 62778, 478, -7738, 6458, 373, -73, 3120, 123, 0),

       (8491, -904, 62778, 478, -7738, 6458, -73, 373, 3120, 123, 0) )



    ,( (11, -312, 902, 23, 321, 2132, 34202, -34, -382),

       (902, -382, 34202, -34, -312, 321, 2132, 23, 11),

       (902, -382, 34202, -34, 2132, -312, 321, 23, 11) )



    ,( (9, 44, 2212, 4, 6, 6, 1, 2, 192, 21, 29384, 0),

       (29384, 192, 9, 6, 6, 4, 44, 2212, 21, 2, 1, 0),

       (29384, 192, 9, 6, 6, 44, 4, 2212, 21, 2, 1, 0),

       (29384, 192, 9, 6, 6, 44, 4, 21, 2212, 2, 1, 0) )



    ,( (44, -88, 9, 233, -3, 14, 101, 77, 555, 67),

       ,(9, -88, 67, 77, 555, 14, 44, 233, -3, 101) )

) | % {

    $a, $expected = $_

    $result = &$f @a

    $true-in($expected|%{"$result"-eq"$_"})

    "$result"

}

Output:

True

8491 -904 62778 478 -7738 6458 -73 373 3120 123 0

True

902 -382 34202 -34 2132 -312 321 23 11

True

29384 192 9 6 6 44 4 21 2212 2 1 0

True

9 -88 67 77 555 14 44 233 -3 101

PHP, 87 86 84 bytes

while(--$argc)$a[_.strrev(count_chars($n=$argv[++$i],3))]=$n;krsort($a);print_r($a);

Run with -nr or try it online.

Replace ++$i with $argc (+1 byte) to suppress the Notice (and render -n obosolete).

breakdown

while(--$argc)  # loop through command line arguments

    $a[                             # key=

        _.                              # 3. prepend non-numeric char for non-numeric sort

        strrev(                         # 2. reverse =^= sort descending

        count_chars($n=$argv[++$i],3)   # 1. get characters used in argument

        )

    ]=$n;                           # value=argument

krsort($a);     # sort by key descending

print_r($a);    # print

- is "smaller" than the digits, so it has no affect on the sorting.

Common Lisp, 88 bytes

(sort(read)'string> :key(lambda(x)(sort(remove-duplicates(format()"~d"(abs x)))'char>)))

Try it online!

Good old verbose Common Lisp!

Explanation:

(sort                   ; sort

 (read)                 ; what to sort: a list of numbers, read on input stream 

 'string>               ; comparison predicate (remember: this is a typed language!)

 :key (lambda (x)       ; how to get an element to sort; get a number

       (sort (remove-duplicates  ; then sort the unique digits (characters) 

               (format() "~d" (abs x))) ; from its string representation

             'char>)))  ; with the appropriate comparison operator for characters

C# (Visual C# Interactive Compiler), 75 74 bytes

-1 thanks @ASCII-only

x=>x.OrderByDescending(y=>String.Concat((y+"").Distinct().OrderBy(z=>-z)))

Try it online!

In C#, strings are considered "enumerables" of characters. I use this to my advantage by first converting each number to a string. LINQ is then leveraged to get the unique characters (digits) sorted in reverse order. I convert each sorted character array back into a string and use that as the sort key to order the whole list.