@teleporthq/teleport-uidl-validator 0.19.8 → 0.19.21

package/src/decoders/utils.ts

@@ -37,8 +37,8 @@ import {
   UIDLStyleMediaQueryScreenSizeCondition,
   UIDLStyleConditions,
   UIDLElementNodeProjectReferencedStyle,
-  UIDLComponentSEO,
-  UIDLGlobalAsset,
+  VUIDLComponentSEO,
+  VUIDLGlobalAsset,
   UIDLExternalDependency,
   UIDLLocalDependency,
   UIDLPeerDependency,
@@ -63,14 +63,15 @@ import {
   UIDLStateModifierEvent,
   UIDLScriptExternalAsset,
   UIDLScriptInlineAsset,
-  UIDLStyleInlineAsset,
+  VUIDLStyleInlineAsset,
   UIDLStyleExternalAsset,
-  UIDLFontAsset,
+  VUIDLFontAsset,
   UIDLCanonicalAsset,
   UIDLIconAsset,
   UIDLAssetBase,
   VUIDLElementNodeClassReferencedStyle,
   UIDLCompDynamicReference,
+  UIDLComponentStyleReference,
 } from '@teleporthq/teleport-types'
 import { CustomCombinators } from './custom-combinators'
 
@@ -166,7 +167,7 @@ export const pageOptionsDecoder: Decoder<UIDLPageOptions> = object({
   fileName: optional(isValidFileName() as unknown as Decoder<string>),
 })
 
-export const globalAssetsDecoder: Decoder<UIDLGlobalAsset> = union(
+export const globalAssetsDecoder: Decoder<VUIDLGlobalAsset> = union(
   lazy(() => inlineScriptAssetDecoder),
   lazy(() => externalScriptAssetDecoder),
   lazy(() => inlineStyletAssetDecoder),
@@ -202,8 +203,9 @@ export const externalScriptAssetDecoder: Decoder<UIDLScriptExternalAsset> = inte
   optional(baseAssetDecoder)
 )
 
-export const inlineStyletAssetDecoder: Decoder<UIDLStyleInlineAsset> = object({
+export const inlineStyletAssetDecoder: Decoder<VUIDLStyleInlineAsset> = object({
   type: constant('style' as const),
+  attrs: optional(dict(union(staticValueDecoder, string(), boolean(), number()))),
   content: string(),
 })
 
@@ -212,8 +214,9 @@ export const externalStyleAssetDecoder: Decoder<UIDLStyleExternalAsset> = object
   path: string(),
 })
 
-export const fontAssetDecoder: Decoder<UIDLFontAsset> = object({
+export const fontAssetDecoder: Decoder<VUIDLFontAsset> = object({
   type: constant('font' as const),
+  attrs: optional(dict(union(staticValueDecoder, string(), boolean(), number()))),
   path: string(),
 })
 
@@ -233,7 +236,7 @@ export const iconAssetDecoder: Decoder<UIDLIconAsset> = object({
   ),
 })
 
-export const componentSeoDecoder: Decoder<UIDLComponentSEO> = object({
+export const componentSeoDecoder: Decoder<VUIDLComponentSEO> = object({
   title: optional(string()),
   metaTags: optional(array(dict(string()))),
   assets: optional(array(globalAssetsDecoder)),
@@ -329,9 +332,15 @@ export const importReferenceDecoder: Decoder<UIDLImportReference> = object({
 export const attributeValueDecoder: Decoder<UIDLAttributeValue> = union(
   dynamicValueDecoder,
   staticValueDecoder,
-  importReferenceDecoder
+  importReferenceDecoder,
+  lazy(() => uidlComponentStyleReference)
 )
 
+export const uidlComponentStyleReference: Decoder<UIDLComponentStyleReference> = object({
+  type: constant('comp-style'),
+  content: string(),
+})
+
 export const styleValueDecoder: Decoder<UIDLStyleValue> = union(
   staticValueDecoder,
   dynamicValueDecoder

package/src/parser/index.ts

@@ -13,6 +13,9 @@ import {
   UIDLStyleSetConditions,
   UIDLDesignTokens,
   ParserError,
+  UIDLComponentSEO,
+  VUIDLGlobalAsset,
+  UIDLGlobalAsset,
 } from '@teleporthq/teleport-types'
 
 interface ParseComponentJSONParams {
@@ -25,7 +28,7 @@ export const parseComponentJSON = (
 ): ComponentUIDL => {
   const safeInput = params.noClone ? input : UIDLUtils.cloneObject(input)
 
-  if (input?.styleSetDefinitions) {
+  if (safeInput?.styleSetDefinitions) {
     const { styleSetDefinitions } = safeInput
 
     Object.values(styleSetDefinitions).forEach((styleRef) => {
@@ -42,6 +45,13 @@ export const parseComponentJSON = (
     })
   }
 
+  if (safeInput?.seo) {
+    const { seo } = safeInput
+    const { assets = [] } = (seo as UIDLComponentSEO) || { assets: [] }
+
+    assets.forEach(parseAssets)
+  }
+
   const node = safeInput.node as Record<string, unknown>
   const result: ComponentUIDL = {
     ...(safeInput as unknown as ComponentUIDL),
@@ -68,6 +78,8 @@ export const parseProjectJSON = (
   }
   result.root = parseComponentJSON(root, { noClone: true })
 
+  result.globals?.assets?.forEach(parseAssets)
+
   if (result.root?.designLanguage) {
     const { tokens = {} } = result.root.designLanguage
 
@@ -225,3 +237,14 @@ const parseComponentNode = (node: Record<string, unknown>): UIDLNode => {
       throw new ParserError(`parseComponentNode attempted to parsed invalid node type ${node.type}`)
   }
 }
+
+export const parseAssets = (asset: VUIDLGlobalAsset): UIDLGlobalAsset => {
+  if ('attrs' in asset) {
+    asset.attrs = UIDLUtils.transformAttributesAssignmentsToJson(asset.attrs) as Record<
+      string,
+      UIDLStaticValue
+    >
+  }
+
+  return asset as UIDLGlobalAsset
+}

package/src/validator/index.ts

@@ -17,7 +17,9 @@ interface ValidationResult {
 }
 
 export default class Validator {
-  public validateComponentSchema(input: Record<string, unknown>): ValidationResult {
+  public validateComponentSchema(
+    input: Record<string, unknown> | VComponentUIDL
+  ): ValidationResult {
     try {
       const cleanedUIDL = utils.validateNulls(input)
       const uidl = componentUIDLDecoder.runWithException(cleanedUIDL)
@@ -30,7 +32,9 @@ export default class Validator {
     }
   }
 
-  public validateRootComponentSchema(input: Record<string, unknown>): ValidationResult {
+  public validateRootComponentSchema(
+    input: Record<string, unknown> | VComponentUIDL
+  ): ValidationResult {
     try {
       const cleanedUIDL = utils.validateNulls(input)
       const uidl = rootComponentUIDLDecoder.runWithException(cleanedUIDL)
@@ -43,7 +47,7 @@ export default class Validator {
     }
   }
 
-  public validateProjectSchema(input: Record<string, unknown>): ValidationResult {
+  public validateProjectSchema(input: Record<string, unknown> | VProjectUIDL): ValidationResult {
     try {
       const cleanedUIDL = utils.validateNulls(input)
       const uidl = projectUIDLDecoder.runWithException(cleanedUIDL)

package/src/validator/utils.ts

@@ -100,6 +100,27 @@ export const checkDynamicDefinitions = (input: Record<string, unknown>) => {
   const errors: string[] = []
 
   UIDLUtils.traverseNodes(input.node as UIDLNode, (node) => {
+    if (node.type === 'element') {
+      const { content } = node
+      const compStyleReference = Object.values(content?.attrs || {}).find(
+        (attr) => attr.type === 'comp-style'
+      )
+
+      if (
+        compStyleReference &&
+        content.elementType !== 'component' &&
+        content?.dependency?.type === 'local'
+      ) {
+        const errorMsg = `${JSON.stringify(
+          compStyleReference,
+          null,
+          2
+        )} can only be assigned on a local component instances. Tried to assign on ${content}`
+
+        errors.push(errorMsg)
+      }
+    }
+
     if (node.type === 'element') {
       Object.keys(node.content?.events || {}).forEach((eventKey) => {
         node.content.events[eventKey].forEach((event) => {