◆ static にせず module 内のトップレベルの変数にすれば楽
  ◆ 継承は super でアクセスできないので少し面倒になる
◆ constructor を別名に置き換える
  ◆ $ がいいけど querySelector であって欲しい感もあるからイマイチ
◆ $ から始まるプロパティをプロキシする
  ◆ プロキシはあんまり良い方法じゃないと思う

static プロパティへアクセスすることがわりと多い

JavaScript でインスタンスメソッドから static プロパティ(関数含む)にアクセスしたいことはけっこうあります
全部インスタンスにすればいい派の人もいますが 私は this を使わず状態に依存しないメソッドは static にしたい派です
インスタンスメソッドだと 状態に依存するので読むときに複雑度が増しますが static だと this の状態の影響は受けず引数だけで結果が決まると考えられるので読みやすいです
static は外部の関数と同じようなものなので状態がどう変わるかを調べるときには 非 static メソッドだけ見ればいいですからね
const にしておけば途中で変わらないので見やすいみたいなものです
一応 this は暗黙的に引数で受け取ってると考えてもいいですが this の場合は気軽にそのプロパティを更新します
this 以外の引数として受け取ったオブジェクトは 一部の引数を更新することが目的の関数でもないと引数は変更しないです
言語的な制約ではないので書き方次第ではあるのですがそういうふうにしておいたほうが読むときに楽なのでそうしてます
ただ そうなると static プロパティへアクセスすることが結構多くなります

static を使わない

static プロパティは そのクラスでしか使わない専用の処理やデータだから static プロパティとしてるわけですが クラスごとにファイル分けをして module としてロードするなら別に static プロパティでなく普通の変数に入れておくこともできます

const fixed_value = 10800
let variable_value = null

const staticFunction = x => x + 1

export class A {
method() {
variable_value += staticFunction(fixed_value)
this.value = variable_value
}
}

こういう風にすれば static プロパティは不要です
外部から使いたいならその変数も export してしまえば問題ありません

困る部分は継承が扱いづらいくらいです
暗黙的に継承はできませんが明示的に書けばできます

static でやった場合
/// a.js
export class A {
static smethod() {
return 10
}
}

/// b.js
import { A } from "./a.js"
export class B extends A{ }

/// c.js
import { B } from "./b.js"
export class C extends B {
static smethod() {
return super.smethod() + 1
}
}

/// main.js
import { C } from "./c.js"
console.log(C.smethod())
// 11

static なしでやった場合
/// a.js
export const fn = () => 10
export default class A { }

/// b.js
import A, * as a from "./a.js"
export const fn = a.fn
export default class B extends A{ }

/// c.js
import B, * as b from "./b.js"
export const fn = () => b.fn() + 1
export default class C extends B { }

/// main.js
import C, * as c from "./c.js"
console.log(c.fn())
// 11

static にアクセスしやすくする

別の方法で static は使うけどアクセスしやすくすることを考えます
普通にやると this.constructor.staticMethod というアクセス方法になるのですが constructor が長くて嫌です
あとなぜか VSCode 使ってると constructor は補完候補に出ないので入力しづらいです

単純な方法で $ プロパティに constructor を代入します

class Base {
$ = this.constructor
}

class Class extends Base {
static foo() {
console.log(1)
}

bar() {
this.$.foo()
}
}

new Class().bar()
// 1

「static.」 で書けるのが理想ですが 「this.$.」 でも文字数は一緒で結構楽です
共通のベースクラスで定義しておけば各クラスで定義する必要がありません

$ 記号は特殊感ありますし S なので static 感もあってけっこう向いてるのですが クエリセレクタによく使われる記号です
私の場合は JavaScript でクラスを使うシーンって CustomElements のために HTMLElement を継承してるものが多いです
そうなると $ は shadowRoot.querySelector であってほしいことが多くて static 代わりにするのは向いてない気もします
他の文字列だと static らしさが足りなくて らしさを出すと文字が長くなって constructor と大差なくなります

そこで $ から始まるプロパティは static 参照とかすればいいのかなと思い付きでやってみました
this.$foo は this.constructor.foo へのアクセスと同じになります

const proto = new Proxy(
{},
{
get(_, name, receiver) {
let prop
if (name[0] === "$") {
prop = receiver.constructor[name.slice(1)]
} else {
prop = receiver[name]
}
if (typeof prop === "function") {
return prop.bind(receiver)
} else {
return prop
}
},
}
)

function Base() {}
Base.prototype = proto

class Class extends Base {
static foo() {
console.log(1)
}

bar() {
this.$foo()
}
}
new Class().bar()
// 1

一応動きはしますが Proxy ってなんか個人的にはデバッグ用と以外で使いたくない気がするので 実用はしないです

追記

static を使わない方法のやつ もう少し改良できそうだったのでやってみました
モジュールのトップレベルではなく あるオブジェクトのプロパティにします
static という名前にすれば 見た目いい感じです

const static = {
fn() { return 1 }
}

class X {
method() {
this.value = static.fn()
}
}

ただ 残念なことに module では strict mode が強制されて static は予約後なので使えません
strict mode とかいらないのに……

しかたないので stc という変数名にしました
stc 変数はクラスとは別に export してもいいですが クラスのプロパティに入れておけば static プロパティと同じように扱えます
Object.assign にするとほぼ同じものになりますが getter や setter を使う可能性も考えて stc というプロパティに代入することにしてます

/// a.js
const stc = {
fn(){ return 1 }
}

class A {}
A.stc = stc
export { A }

/// b.js
import { A } from "./a.js"
const stc = {}
stc.__proto__ = A.stc

class B {}
B.stc = stc
export { B }

/// c.js
import { B } from "./b.js"
const stc = {
fn() { return super.fn() + 1 }
}
stc.__proto__ = B.stc

class C {
method() { return stc.fn() }
}
C.stc = stc
export { C }

/// main.js
import { C } from "./c.js"
console.log(C.stc.fn())
//2

外部から使うときに stc を経由する必要がありますけど 内部で頻繁に書くのに constructor って書くのが嫌というのが理由なので ここはあまり気にしないです
また オブジェクトにしたことで prototype のチェーンをつなげるので super を使って楽に親の static へアクセスできるようになりました

ですが これ 逆にしたほうが簡単な気がします
c.js の場合だと

import { B } from "./b.js"

class C {
static fn() {
return super.fn() + 1
}

method() {
return stc.fn()
}
}

const stc = C
export { C }

凄くシンプルですね
考えてみればこれで何の問題もなかったわけです

一応 C.fn とすれば代入すらいらないのですが 例なので C の 1 文字だけですが実際にはもっと長くなります
なので見やすさとタイプしやすさ的に代入したほうが良いと思います
あと直接クラス名を書くと クラス名を変えた場合に変更しないといけないところが多くなります
この方法だとファイル内は 3 箇所で済みます
最初からすべて stc って名前のクラスにして export 時に変えればもう一つ減りますが デバッグ時に不便になるのでクラス名はちゃんとつけてます