sanity-plugin-seofields 1.0.8 → 1.0.10

package/src/utils/utils.ts

@@ -1,4 +1,4 @@
-export const isEmpty = (value: any): boolean => {
+export const isEmpty = (value: unknown): boolean => {
   return (
     value === null ||
     value === undefined ||
@@ -6,4 +6,4 @@ export const isEmpty = (value: any): boolean => {
     (Array.isArray(value) && value.length === 0) ||
     (typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length === 0)
   )
-}
+}

package/src/types/index.ts

@@ -1,241 +0,0 @@
-export type MetaAttribute = {
-  _type: 'metaAttribute'
-  key?: string
-  type?: 'string' | 'image'
-  value?: string
-  image?: {
-    asset?: {
-      _ref: string
-      _type: 'reference'
-      _weak?: boolean
-      [internalGroqTypeReferenceTo]?: 'sanity.imageAsset'
-    }
-    media?: unknown
-    hotspot?: SanityImageHotspot
-    crop?: SanityImageCrop
-    _type: 'image'
-  }
-}
-
-export type MetaTag = {
-  _type: 'metaTag'
-  metaAttributes?: Array<
-    {
-      _key: string
-    } & MetaAttribute
-  >
-}
-
-export type SeoFields = {
-  _type: 'seoFields'
-  robots?: Robots
-  preview?: string
-  title?: string
-  description?: string
-  metaImage?: {
-    asset?: {
-      _ref: string
-      _type: 'reference'
-      _weak?: boolean
-      [internalGroqTypeReferenceTo]?: 'sanity.imageAsset'
-    }
-    media?: unknown
-    hotspot?: SanityImageHotspot
-    crop?: SanityImageCrop
-    _type: 'image'
-  }
-  metaAttributes?: Array<MetaAttribute>
-  keywords?: Array<string>
-  canonicalUrl?: string
-  openGraph?: OpenGraph
-  twitter?: Twitter
-}
-
-export type Twitter = {
-  _type: 'twitter'
-  card?: 'summary' | 'summary_large_image' | 'app' | 'player'
-  site?: string
-  creator?: string
-  title?: string
-  description?: string
-  image?: {
-    asset?: {
-      _ref: string
-      _type: 'reference'
-      _weak?: boolean
-      [internalGroqTypeReferenceTo]?: 'sanity.imageAsset'
-    }
-    media?: unknown
-    hotspot?: SanityImageHotspot
-    crop?: SanityImageCrop
-    alt?: string
-    _type: 'image'
-  }
-}
-
-export type OpenGraph = {
-  _type: 'openGraph'
-  title?: string
-  url?: string
-  description?: string
-  siteName?: string
-  type?: 'website' | 'article' | 'profile' | 'book' | 'music' | 'video' | 'product'
-  imageType?: 'upload' | 'url'
-  image?: {
-    asset?: {
-      _ref: string
-      _type: 'reference'
-      _weak?: boolean
-      [internalGroqTypeReferenceTo]?: 'sanity.imageAsset'
-    }
-    media?: unknown
-    hotspot?: SanityImageHotspot
-    crop?: SanityImageCrop
-    _type: 'image'
-  }
-  imageUrl?: string
-}
-
-export type Robots = {
-  _type: 'robots'
-  noIndex?: boolean
-  noFollow?: boolean
-}
-
-export type SanityImagePaletteSwatch = {
-  _type: 'sanity.imagePaletteSwatch'
-  background?: string
-  foreground?: string
-  population?: number
-  title?: string
-}
-
-export type SanityImagePalette = {
-  _type: 'sanity.imagePalette'
-  darkMuted?: SanityImagePaletteSwatch
-  lightVibrant?: SanityImagePaletteSwatch
-  darkVibrant?: SanityImagePaletteSwatch
-  vibrant?: SanityImagePaletteSwatch
-  dominant?: SanityImagePaletteSwatch
-  lightMuted?: SanityImagePaletteSwatch
-  muted?: SanityImagePaletteSwatch
-}
-
-export type SanityImageDimensions = {
-  _type: 'sanity.imageDimensions'
-  height: number
-  width: number
-  aspectRatio: number
-}
-
-export type SanityImageHotspot = {
-  _type: 'sanity.imageHotspot'
-  x: number
-  y: number
-  height: number
-  width: number
-}
-
-export type SanityImageCrop = {
-  _type: 'sanity.imageCrop'
-  top: number
-  bottom: number
-  left: number
-  right: number
-}
-
-export type SanityFileAsset = {
-  _id: string
-  _type: 'sanity.fileAsset'
-  _createdAt: string
-  _updatedAt: string
-  _rev: string
-  originalFilename?: string
-  label?: string
-  title?: string
-  description?: string
-  altText?: string
-  sha1hash?: string
-  extension?: string
-  mimeType?: string
-  size?: number
-  assetId?: string
-  uploadId?: string
-  path?: string
-  url?: string
-  source?: SanityAssetSourceData
-}
-
-export type SanityImageAsset = {
-  _id: string
-  _type: 'sanity.imageAsset'
-  _createdAt: string
-  _updatedAt: string
-  _rev: string
-  originalFilename?: string
-  label?: string
-  title?: string
-  description?: string
-  altText?: string
-  sha1hash?: string
-  extension?: string
-  mimeType?: string
-  size?: number
-  assetId?: string
-  uploadId?: string
-  path?: string
-  url?: string
-  metadata?: SanityImageMetadata
-  source?: SanityAssetSourceData
-}
-
-export type SanityImageMetadata = {
-  _type: 'sanity.imageMetadata'
-  location?: Geopoint
-  dimensions?: SanityImageDimensions
-  palette?: SanityImagePalette
-  lqip?: string
-  blurHash?: string
-  hasAlpha?: boolean
-  isOpaque?: boolean
-}
-
-export type Geopoint = {
-  _type: 'geopoint'
-  lat?: number
-  lng?: number
-  alt?: number
-}
-
-export type Slug = {
-  _type: 'slug'
-  current: string
-  source?: string
-}
-
-export type SanityAssetSourceData = {
-  _type: 'sanity.assetSourceData'
-  name?: string
-  id?: string
-  url?: string
-}
-
-export type AllSanitySchemaTypes =
-  | MetaAttribute
-  | MetaTag
-  | SeoFields
-  | Twitter
-  | OpenGraph
-  | Robots
-  | SanityImagePaletteSwatch
-  | SanityImagePalette
-  | SanityImageDimensions
-  | SanityImageHotspot
-  | SanityImageCrop
-  | SanityFileAsset
-  | SanityImageAsset
-  | SanityImageMetadata
-  | Geopoint
-  | Slug
-  | SanityAssetSourceData
-export declare const internalGroqTypeReferenceTo: unique symbol

package/src/utils/generaeDynamicJsonLd.ts

@@ -1,295 +0,0 @@
-import {SchemaTypeDefinition} from 'sanity'
-// Import all schema definitions
-import allSchemas from '../schemas/types'
-
-interface JsonSchemaProperty {
-  type?: string | string[]
-  items?: JsonSchemaProperty
-  properties?: Record<string, JsonSchemaProperty>
-  required?: string[]
-  enum?: string[]
-  const?: any
-  default?: any
-  description?: string
-  maxLength?: number
-  minLength?: number
-  pattern?: string
-  format?: string
-  $ref?: string
-  allOf?: JsonSchemaProperty[]
-  additionalProperties?: boolean
-}
-
-interface JsonSchema {
-  $schema: string
-  title: string
-  description: string
-  type: string
-  definitions: Record<string, JsonSchemaProperty>
-  properties: Record<string, JsonSchemaProperty>
-  additionalProperties: boolean
-}
-
-/**
- * Converts Sanity field type to JSON Schema type
- */
-function mapSanityTypeToJsonSchema(sanityType: string): string | string[] {
-  const typeMap: Record<string, string | string[]> = {
-    string: 'string',
-    text: 'string',
-    number: 'number',
-    boolean: 'boolean',
-    array: 'array',
-    object: 'object',
-    image: 'object',
-    url: 'string',
-    date: 'string',
-    datetime: 'string',
-    reference: 'object',
-  }
-
-  return typeMap[sanityType] || 'string'
-}
-
-/**
- * Converts Sanity field definition to JSON Schema property
- */
-function convertSanityFieldToJsonSchema(field: any): JsonSchemaProperty {
-  const jsonSchemaProperty: JsonSchemaProperty = {
-    type: mapSanityTypeToJsonSchema(field.type),
-  }
-
-  // Add description
-  if (field.description) {
-    jsonSchemaProperty.description = field.description
-  }
-
-  // Handle validation rules
-  if (field.validation) {
-    // This would need to be expanded based on your validation rules
-    // For now, we'll handle common cases
-  }
-
-  // Handle different field types
-  switch (field.type) {
-    case 'string':
-      if (field.options?.list) {
-        jsonSchemaProperty.enum = field.options.list.map((item: any) =>
-          typeof item === 'string' ? item : item.value,
-        )
-      }
-      if (field.validation) {
-        // Add length constraints if available
-      }
-      break
-
-    case 'text':
-      jsonSchemaProperty.type = 'string'
-      break
-
-    case 'url':
-      jsonSchemaProperty.type = 'string'
-      jsonSchemaProperty.format = 'uri'
-      break
-
-    case 'array':
-      jsonSchemaProperty.type = 'array'
-      if (field.of && field.of[0]) {
-        if (typeof field.of[0] === 'string') {
-          jsonSchemaProperty.items = {type: 'string'}
-        } else if (field.of[0].type) {
-          jsonSchemaProperty.items = convertSanityFieldToJsonSchema(field.of[0])
-        }
-      }
-      break
-
-    case 'object':
-      jsonSchemaProperty.type = 'object'
-      if (field.fields) {
-        jsonSchemaProperty.properties = {}
-        const required: string[] = []
-
-        field.fields.forEach((subField: any) => {
-          if (subField.name) {
-            jsonSchemaProperty.properties![subField.name] = convertSanityFieldToJsonSchema(subField)
-            if (subField.required) {
-              required.push(subField.name)
-            }
-          }
-        })
-
-        if (required.length > 0) {
-          jsonSchemaProperty.required = required
-        }
-      }
-      jsonSchemaProperty.additionalProperties = false
-      break
-
-    case 'image':
-      jsonSchemaProperty.$ref = '#/definitions/SanityImage'
-      break
-
-    case 'reference':
-      jsonSchemaProperty.type = 'object'
-      jsonSchemaProperty.properties = {
-        _ref: {type: 'string'},
-        _type: {type: 'string', const: 'reference'},
-      }
-      jsonSchemaProperty.required = ['_ref', '_type']
-      break
-  }
-
-  // Handle initial values as defaults
-  if (field.initialValue !== undefined) {
-    jsonSchemaProperty.default = field.initialValue
-  }
-
-  // Handle hidden fields (not really applicable to JSON Schema but we can note it)
-  if (field.hidden) {
-    jsonSchemaProperty.description = (jsonSchemaProperty.description || '') + ' (Hidden field)'
-  }
-
-  // Handle read-only fields
-  if (field.readOnly) {
-    jsonSchemaProperty.description = (jsonSchemaProperty.description || '') + ' (Read-only)'
-  }
-
-  return jsonSchemaProperty
-}
-
-/**
- * Converts a Sanity schema definition to JSON Schema definition
- */
-function convertSanitySchemaToJsonSchema(schemaDefinition: any): JsonSchemaProperty {
-  const jsonSchemaDefinition: JsonSchemaProperty = {
-    type: 'object',
-    properties: {},
-    additionalProperties: false,
-  }
-
-  // Add _type property
-  if (schemaDefinition.name) {
-    jsonSchemaDefinition.properties!._type = {
-      type: 'string',
-      const: schemaDefinition.name,
-    }
-  }
-
-  // Add title and description
-  if (schemaDefinition.title) {
-    jsonSchemaDefinition.description = schemaDefinition.title
-  }
-
-  // Convert fields
-  if ('fields' in schemaDefinition && schemaDefinition.fields) {
-    const required: string[] = ['_type']
-
-    schemaDefinition.fields.forEach((field: any) => {
-      if (field.name) {
-        jsonSchemaDefinition.properties![field.name] = convertSanityFieldToJsonSchema(field)
-        if (field.required) {
-          required.push(field.name)
-        }
-      }
-    })
-
-    if (required.length > 1) {
-      // More than just _type
-      jsonSchemaDefinition.required = required
-    } else {
-      jsonSchemaDefinition.required = ['_type']
-    }
-  }
-
-  return jsonSchemaDefinition
-}
-
-/**
- * Generates a complete JSON Schema from Sanity schema definitions
- */
-function generateSchemaJson(): JsonSchema {
-  const schemas = allSchemas
-
-  const jsonSchema: JsonSchema = {
-    $schema: 'http://json-schema.org/draft-07/schema#',
-    title: 'Sanity SEO Fields Plugin Schema',
-    description:
-      'Schema definitions for SEO fields including meta tags, Open Graph, and X (Formerly Twitter) Card settings',
-    type: 'object',
-    definitions: {},
-    properties: {},
-    additionalProperties: false,
-  }
-
-  // Add SanityImage definition
-  jsonSchema.definitions.SanityImage = {
-    type: 'object',
-    properties: {
-      _type: {type: 'string', const: 'image'},
-      asset: {
-        type: 'object',
-        properties: {
-          _ref: {type: 'string'},
-          _type: {type: 'string', const: 'reference'},
-        },
-        required: ['_ref', '_type'],
-      },
-      hotspot: {
-        type: 'object',
-        properties: {
-          x: {type: 'number'},
-          y: {type: 'number'},
-          height: {type: 'number'},
-          width: {type: 'number'},
-        },
-      },
-      crop: {
-        type: 'object',
-        properties: {
-          top: {type: 'number'},
-          bottom: {type: 'number'},
-          left: {type: 'number'},
-          right: {type: 'number'},
-        },
-      },
-      alt: {type: 'string'},
-    },
-    required: ['_type', 'asset'],
-  }
-
-  // Convert each schema
-  schemas().forEach((schema) => {
-    if (schema.name) {
-      const jsonSchemaDefinition = convertSanitySchemaToJsonSchema(schema)
-      jsonSchema.definitions[schema.name] = jsonSchemaDefinition
-      jsonSchema.properties[schema.name] = {$ref: `#/definitions/${schema.name}`}
-    }
-  })
-
-  return jsonSchema
-}
-
-/**
- * Writes the generated schema to a file
- */
-export function writeSchemaJson(outputPath: string = './schema.json'): void {
-  const schema = generateSchemaJson()
-  const fs = require('fs')
-
-  try {
-    fs.writeFileSync(outputPath, JSON.stringify(schema, null, 2))
-    console.log(`✅ Schema.json generated successfully at: ${outputPath}`)
-  } catch (error) {
-    console.error('❌ Error writing schema.json:', error)
-    throw error
-  }
-}
-
-/**
- * Returns the generated schema as an object
- */
-export function getSchemaJson(): JsonSchema {
-  return generateSchemaJson()
-}
-
-export default generateSchemaJson