amf-aml/shared/src/main/scala/amf/aml/client/platform/model/domain/ConditionalNodeMapping.scala

@@ -0,0 +1,43 @@
+package amf.aml.client.platform.model.domain
+
+import amf.core.client.platform.model.StrField
+import amf.aml.internal.convert.VocabulariesClientConverter._
+import amf.core.client.platform.model.domain.{DomainElement, Linkable}
+
+import scala.scalajs.js.annotation.{JSExportAll, JSExportTopLevel}
+import amf.aml.client.scala.model.domain.{ConditionalNodeMapping => InternalConditionalNodeMapping}
+
+@JSExportAll
+case class ConditionalNodeMapping(override private[amf] val _internal: InternalConditionalNodeMapping)
+    extends DomainElement
+    with Linkable {
+
+  @JSExportTopLevel("ConditionalNodeMapping")
+  def this() = this(InternalConditionalNodeMapping())
+
+  def name: StrField = _internal.name
+
+  def withName(name: String): ConditionalNodeMapping = {
+    _internal.withName(name)
+    this
+  }
+
+  def ifMapping(): StrField   = _internal.ifMapping
+  def thenMapping(): StrField = _internal.thenMapping
+  def elseMapping(): StrField = _internal.elseMapping
+
+  override def linkCopy(): ConditionalNodeMapping = ConditionalNodeMapping(_internal.linkCopy())
+
+  def withIfMapping(ifMapping: String): ConditionalNodeMapping = {
+    _internal.withIfMapping(ifMapping)
+    this
+  }
+  def withThenMapping(thenMapping: String): ConditionalNodeMapping = {
+    _internal.withIfMapping(thenMapping)
+    this
+  }
+  def withElseMapping(elseMapping: String): ConditionalNodeMapping = {
+    _internal.withIfMapping(elseMapping)
+    this
+  }
+}

amf-aml/shared/src/main/scala/amf/aml/client/scala/AMLDialectResult.scala

@@ -4,6 +4,11 @@ import amf.aml.client.scala.model.document.{Dialect, DialectInstance, Vocabulary
 import amf.core.client.scala.{AMFParseResult, AMFResult}
 import amf.core.client.scala.validation.AMFValidationResult
 
+private[amf] object AMLDialectResult {
+  def unapply(result: AMLDialectResult): Option[(Dialect, Seq[AMFValidationResult])] =
+    Some((result.dialect, result.results))
+}
+
 class AMLDialectResult(val dialect: Dialect, results: Seq[AMFValidationResult])
     extends AMFParseResult(dialect, results)
 

amf-aml/shared/src/main/scala/amf/aml/client/scala/model/domain/ConditionalNodeMapping.scala

@@ -0,0 +1,39 @@
+package amf.aml.client.scala.model.domain
+
+import amf.aml.internal.metamodel.domain.ConditionalNodeMappingModel
+import amf.aml.internal.metamodel.domain.ConditionalNodeMappingModel._
+import amf.core.client.scala.model.StrField
+import amf.core.client.scala.model.domain.{DomainElement, Linkable}
+import amf.core.internal.parser.domain.{Annotations, Fields}
+import amf.core.internal.utils._
+import org.yaml.model.YMap
+
+case class ConditionalNodeMapping(fields: Fields, annotations: Annotations)
+    extends DomainElement
+    with Linkable
+    with MergeableMapping
+    with NodeMappable[ConditionalNodeMappingModel.type] {
+
+  override def meta: ConditionalNodeMappingModel.type = ConditionalNodeMappingModel
+
+  def ifMapping: StrField   = fields.field(If)
+  def thenMapping: StrField = fields.field(Then)
+  def elseMapping: StrField = fields.field(Else)
+
+  def withIfMapping(ifMapping: String): ConditionalNodeMapping     = set(If, ifMapping)
+  def withThenMapping(thenMapping: String): ConditionalNodeMapping = set(Then, thenMapping)
+  def withElseMapping(elseMapping: String): ConditionalNodeMapping = set(Else, elseMapping)
+
+  override def linkCopy(): ConditionalNodeMapping = ConditionalNodeMapping().withId(id)
+  override protected def classConstructor: (Fields, Annotations) => Linkable with DomainElement =
+    ConditionalNodeMapping.apply
+  private[amf] override def componentId: String = "/" + name.value().urlComponentEncoded
+}
+
+object ConditionalNodeMapping {
+  def apply(): ConditionalNodeMapping = apply(Annotations())
+
+  def apply(ast: YMap): ConditionalNodeMapping = apply(Annotations(ast))
+
+  def apply(annotations: Annotations): ConditionalNodeMapping = ConditionalNodeMapping(Fields(), annotations)
+}

amf-aml/shared/src/main/scala/amf/aml/client/scala/model/domain/NodeMapping.scala

@@ -1,11 +1,12 @@
 package amf.aml.client.scala.model.domain
 
 import amf.core.client.scala.model.StrField
-import amf.core.client.scala.model.domain.{DomainElement, Linkable}
+import amf.core.client.scala.model.domain.{DataNode, DomainElement, Linkable}
 import amf.core.internal.parser.domain.{Annotations, Fields}
 import amf.core.internal.utils._
 import amf.aml.internal.metamodel.domain.NodeMappingModel
 import amf.aml.internal.metamodel.domain.NodeMappingModel._
+import amf.core.internal.metamodel.domain.ShapeModel
 import org.yaml.model.YMap
 
 class NodeMapping(override val fields: Fields, override val annotations: Annotations)

amf-aml/shared/src/main/scala/amf/aml/client/scala/model/domain/PropertyMapping.scala

@@ -1,12 +1,13 @@
 package amf.aml.client.scala.model.domain
 
 import amf.core.client.scala.model._
-import amf.core.client.scala.model.domain.AmfScalar
+import amf.core.client.scala.model.domain.{AmfScalar, DataNode}
 import amf.core.client.scala.vocabulary.{Namespace, ValueType}
 import amf.core.internal.metamodel.{Field, Type}
 import amf.core.internal.parser.domain.{Annotations, Fields}
 import amf.aml.internal.metamodel.domain.PropertyMappingModel._
 import amf.aml.internal.metamodel.domain.{DialectDomainElementModel, PropertyMappingModel}
+import amf.core.internal.metamodel.domain.ShapeModel
 import org.yaml.model.YPart
 
 class PropertyClassification
@@ -23,7 +24,8 @@ object ExternalLinkProperty         extends PropertyClassification
 case class PropertyMapping(fields: Fields, annotations: Annotations)
     extends PropertyLikeMapping[PropertyMappingModel.type]
     with MergeableMapping
-    with NodeWithDiscriminator[PropertyMappingModel.type] {
+    with NodeWithDiscriminator[PropertyMappingModel.type]
+    with WithDefaultFacet {
 
   def mapKeyProperty(): StrField   = fields.field(MapKeyProperty)
   def mapValueProperty(): StrField = fields.field(MapValueProperty)

amf-aml/shared/src/main/scala/amf/aml/client/scala/model/domain/UnionNodeMapping.scala

@@ -1,8 +1,9 @@
 package amf.aml.client.scala.model.domain
-import amf.core.client.scala.model.domain.{DomainElement, Linkable}
+import amf.core.client.scala.model.domain.{DataNode, DomainElement, Linkable}
 import amf.core.internal.parser.domain.{Annotations, Fields}
 import amf.core.internal.utils._
 import amf.aml.internal.metamodel.domain.UnionNodeMappingModel
+import amf.core.internal.metamodel.domain.ShapeModel
 import org.yaml.model.YMap
 
 case class UnionNodeMapping(fields: Fields, annotations: Annotations)

amf-aml/shared/src/main/scala/amf/aml/client/scala/model/domain/WithDefaultFacet.scala

@@ -0,0 +1,10 @@
+package amf.aml.client.scala.model.domain
+
+import amf.core.client.scala.model.domain.{DataNode, DomainElement}
+import amf.core.internal.metamodel.domain.ShapeModel
+
+trait WithDefaultFacet extends DomainElement {
+
+  private[amf] def default(): Option[DataNode] = Option(fields.field(ShapeModel.Default))
+  private[amf] def withDefault(node: DataNode) = set(ShapeModel.Default, node)
+}

amf-aml/shared/src/main/scala/amf/aml/internal/annotations/FromUnionRangeMapping.scala

@@ -0,0 +1,9 @@
+package amf.aml.internal.annotations
+
+import amf.core.client.scala.model.domain.Annotation
+
+/*
+  If AMF can't determine a single range for the node this annotation is added to
+  distinguish which ranges where analyzed (ALS uses this to provide suggestions)
+ */
+case class FromUnionRangeMapping(possibleRanges: Seq[String]) extends Annotation

amf-aml/shared/src/main/scala/amf/aml/internal/entities/AMLEntities.scala

@@ -37,7 +37,8 @@ private[amf] object AMLEntities extends Entities {
       AnnotationMappingModel,
       BaseUnitProcessingDataModel,
       BaseUnitSourceInformationModel,
-      LocationInformationModel
+      LocationInformationModel,
+      ConditionalNodeMappingModel
   )
 
 }

amf-aml/shared/src/main/scala/amf/aml/internal/metamodel/domain/AnnotationMappingModel.scala

@@ -2,7 +2,13 @@ package amf.aml.internal.metamodel.domain
 
 import amf.core.internal.metamodel.{Field, Type}
 import amf.core.internal.metamodel.Type.Iri
-import amf.core.internal.metamodel.domain.{DomainElementModel, ExternalModelVocabularies, ModelDoc, ModelVocabularies}
+import amf.core.internal.metamodel.domain.{
+  DomainElementModel,
+  ExternalModelVocabularies,
+  ModelDoc,
+  ModelVocabularies,
+  ShapeModel
+}
 import amf.core.client.scala.vocabulary.{Namespace, ValueType}
 import amf.aml.client.scala.model.domain.AnnotationMapping
 

amf-aml/shared/src/main/scala/amf/aml/internal/metamodel/domain/ConditionalNodeMappingModel.scala

@@ -0,0 +1,47 @@
+package amf.aml.internal.metamodel.domain
+
+import amf.aml.client.scala.model.domain.ConditionalNodeMapping
+import amf.core.client.scala.model.domain.AmfObject
+import amf.core.client.scala.vocabulary.{Namespace, ValueType}
+import amf.core.internal.metamodel.Field
+import amf.core.internal.metamodel.Type.Iri
+import amf.core.internal.metamodel.domain._
+
+object ConditionalNodeMappingModel
+    extends DomainElementModel
+    with LinkableElementModel
+    with MergeableMappingModel
+    with NodeMappableModel {
+
+  val If: Field = Field(
+      Iri,
+      Namespace.AmfAml + "if",
+      ModelDoc(ExternalModelVocabularies.Shacl,
+               "if",
+               "Conditional constraint if over the type of the mapped graph property")
+  )
+
+  val Then: Field = Field(
+      Iri,
+      Namespace.AmfAml + "then",
+      ModelDoc(ExternalModelVocabularies.Shacl,
+               "then",
+               "Conditional constraint then over the type of the mapped graph property")
+  )
+
+  val Else: Field = Field(
+      Iri,
+      Namespace.AmfAml + "else",
+      ModelDoc(ExternalModelVocabularies.Shacl,
+               "else",
+               "Conditional constraint else over the type of the mapped graph property")
+  )
+
+  override val fields
+    : List[Field] = Name :: If :: Then :: Else :: LinkableElementModel.fields ++ DomainElementModel.fields
+
+  override val `type`
+    : List[ValueType] = Namespace.Meta + "ConditionalNodeMapping" :: Namespace.Shacl + "Shape" :: DomainElementModel.`type`
+
+  override def modelInstance: AmfObject = ConditionalNodeMapping()
+}

amf-aml/shared/src/main/scala/amf/aml/internal/metamodel/domain/NodeMappingModel.scala

@@ -4,10 +4,11 @@ import amf.core.internal.metamodel.Field
 import amf.core.internal.metamodel.Type.{Array, Iri, Str}
 import amf.core.internal.metamodel.domain.{
   DomainElementModel,
+  ExternalModelVocabularies,
   LinkableElementModel,
   ModelDoc,
   ModelVocabularies,
-  ExternalModelVocabularies
+  ShapeModel
 }
 import amf.core.client.scala.model.domain.AmfObject
 import amf.core.client.scala.vocabulary.{Namespace, ValueType}

amf-aml/shared/src/main/scala/amf/aml/internal/metamodel/domain/PropertyLikeMappingModel.scala

@@ -2,7 +2,13 @@ package amf.aml.internal.metamodel.domain
 
 import amf.core.internal.metamodel.Field
 import amf.core.internal.metamodel.Type.{Any, Bool, Double, Int, Iri, SortedArray, Str}
-import amf.core.internal.metamodel.domain.{DomainElementModel, ExternalModelVocabularies, ModelDoc, ModelVocabularies}
+import amf.core.internal.metamodel.domain.{
+  DataNodeModel,
+  DomainElementModel,
+  ExternalModelVocabularies,
+  ModelDoc,
+  ModelVocabularies
+}
 import amf.core.client.scala.vocabulary.Namespace
 
 /**
@@ -78,5 +84,4 @@ trait PropertyLikeMappingModel extends DomainElementModel with HasObjectRangeMod
       Namespace.Meta + "externallyLinkable",
       ModelDoc(ModelVocabularies.Meta, "linkable", "Marks this object property as supporting external links")
   )
-
 }

amf-aml/shared/src/main/scala/amf/aml/internal/metamodel/domain/PropertyMappingModel.scala

@@ -2,7 +2,13 @@ package amf.aml.internal.metamodel.domain
 
 import amf.core.internal.metamodel.Field
 import amf.core.internal.metamodel.Type.{Any, Bool, Double, Int, Iri, SortedArray, Str}
-import amf.core.internal.metamodel.domain.{DomainElementModel, ExternalModelVocabularies, ModelDoc, ModelVocabularies}
+import amf.core.internal.metamodel.domain.{
+  DomainElementModel,
+  ExternalModelVocabularies,
+  ModelDoc,
+  ModelVocabularies,
+  ShapeModel
+}
 import amf.core.client.scala.model.domain.AmfObject
 import amf.core.client.scala.vocabulary.{Namespace, ValueType}
 import amf.aml.client.scala.model.domain.PropertyMapping
@@ -44,7 +50,7 @@ object PropertyMappingModel
     NodePropertyMapping :: Name :: LiteralRange :: ObjectRange ::
       MapKeyProperty :: MapValueProperty :: MapTermKeyProperty :: MapTermValueProperty ::
       MinCount :: Pattern :: Minimum :: Maximum :: AllowMultiple :: Sorted :: Enum :: TypeDiscriminator ::
-      Unique :: ExternallyLinkable :: TypeDiscriminatorName :: MergePolicy :: DomainElementModel.fields
+      Unique :: ExternallyLinkable :: TypeDiscriminatorName :: MergePolicy :: ShapeModel.Default :: DomainElementModel.fields
 
   override def modelInstance: AmfObject = PropertyMapping()
 

amf-aml/shared/src/main/scala/amf/aml/internal/parse/dialects/DialectContext.scala

@@ -4,6 +4,9 @@ import amf.core.client.scala.model.document.RecursiveUnit
 import amf.core.client.scala.parse.document.{ParserContext, SyamlBasedParserErrorHandler}
 import amf.core.internal.utils.QName
 import amf.aml.internal.parse.common.{DeclarationContext, SyntaxErrorReporter}
+import amf.core.client.scala.model.domain.extensions.CustomDomainProperty
+import amf.core.internal.datanode.DataNodeParserContext
+import amf.core.internal.parser.domain.{FragmentRef, SearchScope}
 import amf.core.internal.plugins.syntax.SYamlAMFParserErrorHandler
 
 class DialectContext(private val wrapped: ParserContext, private val ds: Option[DialectDeclarations] = None)
@@ -13,7 +16,8 @@ class DialectContext(private val wrapped: ParserContext, private val ds: Option[
                                          wrapped.config)
     with DialectSyntax
     with DeclarationContext
-    with SyntaxErrorReporter {
+    with SyntaxErrorReporter
+    with DataNodeParserContext {
 
   def findInRecursiveUnits(key: String): Option[String] = {
     val qname = QName(key)
@@ -34,4 +38,7 @@ class DialectContext(private val wrapped: ParserContext, private val ds: Option[
   override val declarations: DialectDeclarations =
     ds.getOrElse(new DialectDeclarations(errorHandler = eh, futureDeclarations = futureDeclarations))
 
+  override def findAnnotation(key: String, scope: SearchScope.Scope): Option[CustomDomainProperty] = None
+  override def getMaxYamlReferences: _root_.scala.Option[Int]                                      = wrapped.config.parsingOptions.maxYamlReferences
+  override def fragments: Map[String, FragmentRef]                                                 = Map.empty
 }

amf-aml/shared/src/main/scala/amf/aml/internal/parse/dialects/DialectSyntax.scala

@@ -6,6 +6,7 @@ trait DialectSyntax { this: DialectContext =>
   type Required = Boolean
 
   val dialect: Map[String, Required] = Map(
+      "$id"                -> false,
       "$type"              -> false,
       "dialect"            -> true,
       "version"            -> true,
@@ -19,6 +20,7 @@ trait DialectSyntax { this: DialectContext =>
   )
 
   val library: Map[String, Required] = Map(
+      "$id"          -> false,
       "$type"        -> false,
       "usage"        -> false,
       "external"     -> false,
@@ -27,12 +29,14 @@ trait DialectSyntax { this: DialectContext =>
   )
 
   val nodeMapping: Map[String, Required] = Map(
-      "classTerm"  -> false,
-      "mapping"    -> false,
-      "idProperty" -> false,
-      "idTemplate" -> false,
-      "patch"      -> false,
-      "extends"    -> false
+      "classTerm"   -> false,
+      "mapping"     -> false,
+      "idProperty"  -> false,
+      "idTemplate"  -> false,
+      "patch"       -> false,
+      "extends"     -> false,
+      "union"       -> false,
+      "conditional" -> false
   )
 
   val propertyLikeMapping: Map[String, Required] = Map(
@@ -56,6 +60,7 @@ trait DialectSyntax { this: DialectContext =>
   )
 
   val fragment: Map[String, Required] = Map(
+      "$id"      -> false,
       "usage"    -> false,
       "external" -> false,
       "uses"     -> false