TypeScript Arayüzleri, özellikler için birlikte oluşma kısıtlamalarını ifade edebilir mi

Bir monolitik Typescript Arayüzü veya Tür tanımlarında, özelliklerin ya birlikte görünmesini ya da hiç görünmemesini sağlamak için standart bir desen var mı?

Örneğin bir öğe, böyle görünüyorsa geçerli olabilir...

{
  id:"ljklkj",
  spellcheck:true,
  spellcheckModel:"byzantine",
}

...veya bu...

{
  id:"ljklkj",
}

Ancak, yazım denetimi özelliklerinden herhangi biri tek başına meydana gelirse bu geçersiz olur.

{
  id:"ljklkj",
  spellcheckModel:"byzantine",
}

{
  id:"ljklkj",
  spellcheck:true,
}

Monolitik

Elbette yukarıdaki basit durum, bir Veri ve bir YazımDenetimiVerisi Türü veya Arayüzü oluşturarak çözülebilir. Ancak benim uygulama durumumda, birden fazla birlikte oluşan özellik 'kümesi' olacak. Birlikte oluşumun her kombinasyonu için yeni bir tür tanımlamak, durumu ifade etmek için türlerin patlamasına yol açardı.

Bu nedenle çözüme 'monolitik' bir arayüz olarak atıfta bulundum. Elbette, bunu tanımlamak için bazı bileşim biçimlerini kullanmak gerekebilir.

Denediğim Şeyler

Typescript dil referansında bunun gibi örnekler bulmaya çalıştım, ama özelliğin ne olarak adlandırılabileceğini bilmeksizin (veya gerçekten ifade edilebilir bir özellik olup olmadığını), zorlanıyorum. Özellikler bireysel olarak isteğe bağlı olabilir ama birlikte ortaya çıkmayı ifade etmenin bir yolunu göremiyorum.

İlgili Teknolojiler

XML veri doğrulaması için eşdeğer bir özellik burada tartışılmaktadır... https://www.w3.org/wiki/Co-occurrence_constraints

JSON için, Schematron ve Json İçerik Kuralları gibi şema dillerinin eş kısıtlamaları ifade edebildiğini anlıyorum.

Çözümlü örnek

Eğer Solr arama motoru için HTTP parametre setlerine uygulanan co-constraint durumu için typescript sözdizimini hayal edecek olsaydım, bu şöyle görünebilir; bu, Spell veya Group parametrelerini tamamen yerine getirmeyi seçebileceğinizi ya da hiç yapmayacağınızı gösterir - her türün isteğe bağlı olduğu bir birleşim (? ile gösterilmiştir) ...

type SolrPassthru =
  SolrCoreParams & (
    SolrSpellParams? |
    SolrGroupParams?  
  )

Bu, aşağıdaki örnekle tezat teşkil ediyor; bence bu doğru Typescript ancak her parametre grubundan TÜM parametreleri gerektiriyor.

type SolrCoreParams = {
  defType: SolrDefType,
  boost: SolrBoostType,
}

type SolrSpellParams = {
  spellcheck: "true" | "false",
  "spellcheck.collate": "true" | "false",
  "spellcheck.maxCollationTries": 1,
}

type SolrGroupParams = {
  group: "true" | "false",
  "group.limit": '4'
  "group.sort": 'group_level asc,score desc,published desc,text_sort asc'
  "group.main": 'true'
  "group.field": 'group_uri'
}

type SolrPassthru =
  SolrCoreParams & 
  SolrSpellParams &
  SolrGroupParams

Cevap #1

Lütfen aşağıdakileri deneyin. Görünüşe göre doğru yerlerde hata gösteriyor.

type None<T> = {[K in keyof T]?: never}
type EitherOrBoth<T1, T2> = T1 & None<T2> | T2 & None<T1> | T1 & T2

interface Data {
  id: string;
}

interface SpellCheckData {
  spellcheck: boolean,
  spellcheckModel: string,
}

// Two interfaces
var z1: EitherOrBoth<Data, SpellCheckData> = { id: "" };
var z2: EitherOrBoth<Data, SpellCheckData> = { spellcheck: true,  spellcheckModel: 'm'};
var z3ERROR: EitherOrBoth<Data, SpellCheckData> = { spellcheck: true};
var z4: EitherOrBoth<Data, SpellCheckData> = { id: "", spellcheck: true,  spellcheckModel: 'm'};

interface MoreData {
  p1: string,
  p2: string,
  p3: string,
}

type Monolith = EitherOrBoth<Data, EitherOrBoth<SpellCheckData, MoreData>>

var x1: Monolith  = { id: "" };
var x2: Monolith  = { spellcheck: true,  spellcheckModel: 'm'};
var x3ERROR: Monolith  = { spellcheck: true};                       
var x4: Monolith  = { id: "", spellcheck: true,  spellcheckModel: 'm'};
var x5ERROR: Monolith  = { p1: ""};                                  
var x6ERROR: Monolith  = { p1: "", p2: ""};
var x7: Monolith  = { p1: "", p2: "", p3: ""};
var x8: Monolith  = { id: "", p1: "", p2: "", p3: ""};
var x9ERROR: Monolith  = { id: "", spellcheck: true, p1: "", p2: "", p3: ""};
var x10: Monolith  = { id: "", spellcheck: true, spellcheckModel: 'm', p1: "", p2: "", p3: ""};

Oyun alanı linki

Güncelleme

Türleri bir demet olarak geçirmek isterseniz, aşağıdaki yardımcı programı kullanabilirsiniz:

type CombinationOf<T> = T extends [infer U1, infer U2] ? EitherOrBoth<U1, U2> :
                        T extends [infer U1, infer U2, infer U3] ? EitherOrBoth<U1, EitherOrBoth<U2, U3>> :
                        T extends [infer U1, infer U2, infer U3, infer U4] ? EitherOrBoth<U1, EitherOrBoth<U2, EitherOrBoth<U3, U4>>> :
                        never;

type Monolith = CombinationOf<[Data, SpellCheckData, MoreData]>

Bazı özellikler gerekli ise:

type Monolith = Data & CombinationOf<[Data, SpellCheckData, MoreData]>

İlgili makaleler