टाइपस्क्रिप्ट अंतर गुण के लिए सह-घटना बाधाओं को व्यक्त कर सकते हैं

Question

क्या एक मोनोलिथिक टाइपस्क्रिप्ट इंटरफ़ेस के भीतर एक मानक पैटर्न है या गुणों को मुखर करने के लिए टाइप परिभाषाएँ या तो एक साथ दिखाई देती हैं या बिल्कुल दिखाई नहीं देती हैं?

उदाहरण के लिए कोई आइटम मान्य हो सकता है अगर वह इस तरह दिखता है ...

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

...या यह...

{
  id:"ljklkj",
}

हालाँकि यह अमान्य होगा यदि दोनों में से किसी एक में वर्तनी जाँचक गुण मौजूद हों।

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

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

अखंड

बेशक ऊपर का सरल मामला एक डेटा और एक स्पेलचेकडाटा प्रकार या इंटरफ़ेस बनाकर हल किया जा सकता है। मेरे आवेदन के मामले में, हालांकि, सह-होने वाली संपत्तियों के एक से अधिक 'क्लस्टर' होंगे। सह-घटना के हर संयोजन के लिए एक नए प्रकार को परिभाषित करने से मामले को व्यक्त करने के लिए प्रकारों का विस्फोट होगा।

इस कारण से मैंने समाधान को 'अखंड' इंटरफ़ेस के रूप में संदर्भित किया है। बेशक इसे परिभाषित करने के लिए रचना के कुछ रूप का उपयोग करना आवश्यक हो सकता है।

मैंने क्या कोशिश की है

मैंने टाइपस्क्रिप्ट भाषा संदर्भ में इस तरह के उदाहरण खोजने की कोशिश की है, लेकिन यह जाने बिना कि फीचर को क्या कहा जा सकता है, (या वास्तव में अगर यह एक ऐसी विशेषता है जिसे बिल्कुल भी व्यक्त किया जा सकता है), मैं संघर्ष कर रहा हूं। गुण व्यक्तिगत रूप से वैकल्पिक हो सकते हैं लेकिन मैं सह-घटना को व्यक्त करने का एक तरीका नहीं देख सकता।

संबंधित प्रौद्योगिकी

XML डेटा सत्यापन के लिए एक समकक्ष सुविधा यहाँ चर्चा की गई है ... https://www.w3.org/wiki/Co-occurrence_constraints

JSON के लिए, मैं समझता हूं कि स्कीमाट्रॉन और Json सामग्री नियम जैसी भाषाएं सह-बाधाओं को व्यक्त करने में सक्षम हैं।

काम का उदाहरण

यदि मैं सोलर खोज इंजन के लिए HTTP पैरामीटर सेट पर लागू सह-बाधा मामले के लिए टाइपस्क्रिप्ट सिंटैक्स की कल्पना करता था, तो यह इस तरह दिखाई दे सकता है, यह दर्शाता है कि आप वर्तनी या समूह params को पूरी तरह से संतुष्ट करने का विकल्प चुन सकते हैं, या बिल्कुल नहीं - एक संघ जिसमें प्रत्येक प्रकार वैकल्पिक है (द्वारा इंगित किया गया है ? ) ...

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

यह नीचे दिए गए उदाहरण के साथ विरोधाभास है, जो मुझे विश्वास है कि सही टाइपस्क्रिप्ट है, लेकिन मापदंडों के प्रत्येक समूह से सभी मापदंडों की आवश्यकता होती है।

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

Answer 1

कृपया निम्नलिखित प्रयास कीजिए। ऐसा लगता है कि यह सही स्थानों पर त्रुटियों को दर्शाता है।

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: ""};

खेल का मैदान लिंक

अपडेट करें

यदि आप एक टपल के रूप में पास करना पसंद करते हैं, तो आप निम्न उपयोगिता का उपयोग कर सकते हैं:

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]>

यदि कुछ गुण आवश्यक हैं:

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