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)

Python 2, 60 55 bytes

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

Try it online!

Ungolfed

def f(l):

  l.sort(        # Sort the list in place

    cmp = None,  # ... with no custom comparison function

    key = k,     # ... on the function

    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!

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, 58 60 bytes

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


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.

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

              )

        )

    ]

}

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

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!

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)

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!

Stax, 6 7 bytes

èó≥ü≤♥¥

Run and debug it

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

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!

C# (Visual C# Interactive Compiler), 84 bytes

x=>x.OrderByDescending(y=>String.Concat((y+"-").Distinct().OrderByDescending(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.

I was scratching my head with how to handle the hyphen for negative numbers. But as it turns out, adding the hyphen character to all of my numbers takes care of the tie breaker when one number has a superset of digits compared to the other.

Julia 1.0, 50 bytes

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

Try it online!

APL (Dyalog Extended), 19 bytes

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

Try it online!

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