@basementstudio/sanity-ai-image-plugin 0.0.1 → 0.1.1

package/src/studio/components/input-router.tsx

@@ -1,41 +0,0 @@
-"use client"
-
-import { useFormValue, type InputProps, type ObjectInputProps } from "sanity"
-import type { ImageValue } from "sanity"
-import { GenerateButtonInput } from "./generate-button-input"
-import { doesTargetMatchField } from "../../utils/document-paths"
-import type { ResolvedOptions } from "../../utils/shared"
-
-export function InputRouter({
-  options,
-  props,
-}: {
-  options: ResolvedOptions
-  props: InputProps
-}) {
-  const documentType = useFormValue(["_type"]) as string | undefined
-
-  if (props.schemaType?.name !== "image") {
-    return props.renderDefault(props)
-  }
-
-  const target = options.targets.find((candidate) =>
-    doesTargetMatchField({
-      documentType,
-      path: props.path,
-      target: candidate,
-    })
-  )
-
-  if (!target) {
-    return props.renderDefault(props)
-  }
-
-  return (
-    <GenerateButtonInput
-      options={options}
-      props={props as ObjectInputProps<ImageValue>}
-      target={target}
-    />
-  )
-}

package/src/studio/files.ts

@@ -1,114 +0,0 @@
-"use client"
-
-function getPngFilename(filename: string): string {
-  const basename = filename.replace(/\.[^/.]+$/, "")
-  return `${basename || "reference"}.png`
-}
-
-export async function convertImageFileToPng(file: File): Promise<File> {
-  if (file.type === "image/png") {
-    return file
-  }
-
-  const imageUrl = URL.createObjectURL(file)
-
-  try {
-    const image = await new Promise<HTMLImageElement>((resolve, reject) => {
-      const nextImage = new Image()
-      nextImage.onload = () => resolve(nextImage)
-      nextImage.onerror = () =>
-        reject(new Error(`Unable to decode ${file.name} as an image.`))
-      nextImage.src = imageUrl
-    })
-    const canvas = document.createElement("canvas")
-    const width = image.naturalWidth || image.width
-    const height = image.naturalHeight || image.height
-
-    canvas.width = width
-    canvas.height = height
-
-    const context = canvas.getContext("2d")
-
-    if (!context) {
-      throw new Error("Unable to convert the reference image to PNG.")
-    }
-
-    context.drawImage(image, 0, 0, width, height)
-
-    const blob = await new Promise<Blob>((resolve, reject) => {
-      canvas.toBlob(
-        (nextBlob) => {
-          if (nextBlob) {
-            resolve(nextBlob)
-            return
-          }
-
-          reject(new Error("Unable to convert the reference image to PNG."))
-        },
-        "image/png",
-        1
-      )
-    })
-
-    return new File([blob], getPngFilename(file.name), { type: "image/png" })
-  } finally {
-    URL.revokeObjectURL(imageUrl)
-  }
-}
-
-export function base64ToBlob(base64: string, mimeType: string): Blob {
-  const binaryString = atob(base64)
-  const bytes = new Uint8Array(binaryString.length)
-
-  for (const [index, character] of Array.from(binaryString).entries()) {
-    bytes[index] = character.charCodeAt(0)
-  }
-
-  return new Blob([bytes], { type: mimeType })
-}
-
-export function fileExtensionFromMimeType(mimeType: string): string {
-  switch (mimeType) {
-    case "image/jpeg":
-      return "jpg"
-    case "image/webp":
-      return "webp"
-    default:
-      return "png"
-  }
-}
-
-export function formatFileSize(bytes: number): string {
-  if (bytes < 1024) {
-    return `${bytes} B`
-  }
-
-  const kilobytes = bytes / 1024
-
-  if (kilobytes < 1024) {
-    return `${kilobytes.toFixed(1)} KB`
-  }
-
-  return `${(kilobytes / 1024).toFixed(1)} MB`
-}
-
-export function createGeneratedFile(
-  result: { data: string; mimeType: string },
-  basename: string,
-  prefix = "ai-image-plugin"
-): File {
-  const extension = fileExtensionFromMimeType(result.mimeType)
-  const timestamp = new Date().toISOString().replaceAll(/[:.]/g, "-")
-  const safeBasename = basename
-    .trim()
-    .toLowerCase()
-    .replaceAll(/[^a-z0-9]+/g, "-")
-    .replaceAll(/^-+|-+$/g, "")
-    .slice(0, 40)
-  const suffix = safeBasename || "generated"
-  const blob = base64ToBlob(result.data, result.mimeType)
-
-  return new File([blob], `${prefix}-${suffix}-${timestamp}.${extension}`, {
-    type: result.mimeType,
-  })
-}

package/src/studio/plugin.tsx

@@ -1,54 +0,0 @@
-import { definePlugin, type AssetSource, type InputProps } from "sanity"
-import { createAssetSource } from "./components/asset-source"
-import { InputRouter } from "./components/input-router"
-import { createSettingsSchema } from "./settings/schema"
-import { createSettingsTool } from "./settings/tool"
-import { normalizeOptions } from "../utils/config"
-import type { PluginOptions } from "../utils/shared"
-
-export const aiImagePlugin = definePlugin<PluginOptions>((rawOptions) => {
-  const options = normalizeOptions(rawOptions)
-  const assetSource = options.assetSourceTarget
-    ? createAssetSource(options)
-    : null
-  const settingsTool = createSettingsTool(options)
-  const settingsSchema = createSettingsSchema(options)
-
-  return {
-    name: "ai-image-plugin",
-    ...(options.registerSettingsSchemaType
-      ? {
-          schema: {
-            types: [settingsSchema],
-          },
-        }
-      : {}),
-    tools: [
-      {
-        name: options.settingsToolName,
-        title: options.settingsToolTitle,
-        component: settingsTool,
-      },
-    ],
-    form: {
-      ...(assetSource
-        ? {
-            image: {
-              assetSources: (previousAssetSources: AssetSource[]) =>
-                previousAssetSources.some(
-                  (previousAssetSource) =>
-                    previousAssetSource.name === assetSource.name
-                )
-                  ? previousAssetSources
-                  : [...previousAssetSources, assetSource],
-            },
-          }
-        : {}),
-      components: {
-        input: (props: InputProps) => (
-          <InputRouter options={options} props={props} />
-        ),
-      },
-    },
-  }
-})

package/src/studio/settings/schema.ts

@@ -1,122 +0,0 @@
-import { defineArrayMember, defineField, defineType } from "sanity"
-import {
-  getDefaultAllowedAiImageModel,
-  getSupportedAiImageModelOptions,
-} from "../../utils/models"
-import {
-  SETTINGS_DOCUMENT_ID,
-  SETTINGS_SCHEMA_TYPE,
-  type ResolvedOptions,
-} from "../../utils/shared"
-
-export function createSettingsSchema(options: ResolvedOptions) {
-  return defineType({
-    name: SETTINGS_SCHEMA_TYPE,
-    title: "AI Image Plugin Settings",
-    type: "document",
-    fields: [
-      defineField({
-        name: "title",
-        title: "Title",
-        type: "string",
-        initialValue: "AI Image Plugin Settings",
-        readOnly: true,
-      }),
-      defineField({
-        name: "globalPrompt",
-        title: "Global Prompt",
-        type: "text",
-        rows: 8,
-        description:
-          "Prompt instructions automatically included in every AI Image Plugin generation.",
-      }),
-      defineField({
-        name: "globalModel",
-        title: "Default Model",
-        type: "string",
-        initialValue: getDefaultAllowedAiImageModel(options.allowedModels),
-        description:
-          "The AI image model used by the plugin unless a different allowed default is configured later.",
-        options: {
-          list: getSupportedAiImageModelOptions(options.allowedModels),
-        },
-      }),
-      defineField({
-        name: "globalReferenceImages",
-        title: "Global Reference Images",
-        type: "array",
-        description:
-          "Reference images automatically included in every AI Image Plugin generation.",
-        of: [
-          defineArrayMember({
-            type: "image",
-            options: { hotspot: true },
-          }),
-        ],
-      }),
-      defineField({
-        name: "targetConfigs",
-        title: "Target Overrides",
-        type: "array",
-        description:
-          "Per-target prompt and reference images for specific AI Image Plugin entry points.",
-        of: [
-          defineArrayMember({
-            type: "object",
-            fields: [
-              defineField({
-                name: "targetId",
-                title: "Target ID",
-                type: "string",
-                validation: (Rule) => Rule.required(),
-                options: {
-                  list: [
-                    ...(options.assetSourceTarget
-                      ? [
-                          {
-                            title:
-                              options.assetSourceTarget.title ||
-                              options.assetSourceTarget.id,
-                            value: options.assetSourceTarget.id,
-                          },
-                        ]
-                      : []),
-                    ...options.targets.map((target) => ({
-                      title: target.title || target.id,
-                      value: target.id,
-                    })),
-                  ],
-                },
-              }),
-              defineField({
-                name: "prompt",
-                title: "Prompt",
-                type: "text",
-                rows: 6,
-              }),
-              defineField({
-                name: "referenceImages",
-                title: "Reference Images",
-                type: "array",
-                of: [
-                  defineArrayMember({
-                    type: "image",
-                    options: { hotspot: true },
-                  }),
-                ],
-              }),
-            ],
-          }),
-        ],
-      }),
-    ],
-    preview: {
-      prepare() {
-        return {
-          title: "AI Image Plugin Settings",
-          subtitle: SETTINGS_DOCUMENT_ID,
-        }
-      },
-    },
-  })
-}