typescript - Tipi derinlemesine yazılabilir yap

Bir TypeScript nesne türünü derinlemesine yazılabilir hâle getirmek, ancak dizi türlerinden readonly tür operatörünü kaldırmak mümkün mü?

Buna benzer, ancak - belirttiğim gibi - dizi türlerinden readonly öğesini de kaldırın.

// if initial type is:
interface InitialType {
  readonly field: string;
  readonly array: readonly { readonly arraySubfield: string; }[];
  readonly obj: {
    readonly objSubfield1: string;
    readonly objSubfield2: readonly string[];
  };
}

// then the result type would be:
interface ResultType {
  field: string;
  array: { arraySubfield: string }[];
  obj: {
    objSubfield1: string;
    objSubfield2: string[];
  };
}

// achieved by doing this:
type ResultType = Writable<InitialType>;

Cevap #1

Buyur, çok fazla şeyi yöneten derin yazılabilir bir tip:

type Writable<T> =
    // check for things that are objects but don't need changing
    T extends ((...args: any[]) => any) | Date | RegExp
        ? T
        : T extends ReadonlyMap<infer K, infer V> // maps
            ? Map<Writable<K>, Writable<V>> // make key and values writable
            : T extends ReadonlySet<infer U> // sets
                ? Set<Writable<U>> // make elements writable
                : T extends ReadonlyArray<unknown> // is an array or tuple?
                    ? `${bigint}` extends `${keyof T & any}` // is tuple
                        ? { -readonly [K in keyof T]: Writable<T[K]> }
                        : Writable<T[number]>[] // is regular array
                    : T extends object // is regular object
                        ? { -readonly [K in keyof T]: Writable<T[K]> }
                        : T; // is primitive or literal value

Esasen bu şöyle:

type Writable<T> = T extends object ? { -readonly [K in keyof T]: Writable<T[K]> } : T;

ama birçok şeyi daha doğru şekilde ele alıyor. Diziler, tarihler, fonksiyonlar, düzenli ifadeler, haritalar, kümeler, demetler, salt okunur haritalar ve salt okunur kümeler gibi (ve sadece) şeyler.

Oyun alanı

Cevap #2

İç içe geçmiş nesnelerden ve T dizilerinden readonly belirtecini kaldırmak için, ts-essentials paketindeki DeepWritable<T> yardımcı türünü kullanmanızı öneririm:

import type { DeepWritable } from "ts-essentials";

type ResultType = DeepWritable<InitialType>;

Kaynağından görebileceğiniz gibi, DeepWritable yardımcı programı Map ve Set gibi türler için çeşitli özel durumlar sağlar, bu yüzden kendi çözümünüzü yaratmaktansa bakımı yapılan bir kütüphaneye güvenmek muhtemelen daha iyidir.

(İpucu için @Blackhole'a teşekkürler.)