@easyling/sanity-connector 0.0.2-rc.1 → 0.0.2-rc.2

package/dist-types/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Main entry point for the Sanity Translation Plugin
+ */
+export { default } from './plugin';
+export type { LocaleDefinition, LocaleConfig, TranslationRequestPayload, TranslationResponse, TranslatableField, DNTFieldPreference, DNTPreferences, DNTTypeConfig, DNTStorage } from './types';
+export type { UnifiedPluginConfig } from './services/unifiedConfigStorage';
+export { createPluginConfigSchema, pluginConfigSchema } from './config/pluginConfig';
+export { DNTFieldBadge, withDNTBadge, DNTFieldInput } from './components/dnt';
+export { DNTStorageAdapter, LegacyDNTStorageAdapter } from './services/dntStorageAdapter';
+export { UnifiedConfigStorage } from './services/unifiedConfigStorage';
+export { DNTServiceManager, getDNTStorage } from './services/dntServiceManager';

package/dist-types/plugin.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("sanity").Plugin<void>;
+export default _default;

package/dist-types/services/authStateManager.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Authentication State Manager
+ *
+ * Manages the overall authentication state and provides reactive updates
+ * to UI components through an observable pattern.
+ *
+ * Requirements: 6.1, 6.2, 6.3, 6.4, 6.5
+ */
+import { AuthState, AuthStateData } from '../types/oauth';
+import { TokenStorage } from './tokenStorage';
+/**
+ * Callback function type for state change subscriptions
+ */
+type StateChangeCallback = (state: AuthStateData) => void;
+/**
+ * Authentication State Manager
+ *
+ * Provides centralized management of authentication state with reactive updates.
+ * Uses observable pattern to notify subscribers of state changes.
+ */
+export declare class AuthStateManager {
+    private currentState;
+    private subscribers;
+    private tokenStorage;
+    /**
+     * Create a new Authentication State Manager
+     *
+     * Requirements: 6.1, 6.2
+     *
+     * @param tokenStorage - Token storage service for persistence
+     */
+    constructor(tokenStorage: TokenStorage);
+    /**
+     * Validate state transition
+     *
+     * Requirements: 6.5
+     *
+     * @param fromState - Current state
+     * @param toState - Target state
+     * @returns True if transition is valid
+     */
+    private isValidTransition;
+    /**
+     * Get current authentication state
+     *
+     * Requirements: 6.1, 6.2
+     *
+     * @returns Current authentication state data
+     */
+    getState(): AuthStateData;
+    /**
+     * Update authentication state and notify subscribers
+     *
+     * Requirements: 6.2, 6.5
+     *
+     * @param state - New authentication state
+     * @param data - Additional state data
+     * @throws {OAuthError} If state transition is invalid
+     */
+    setState(state: AuthState, data?: Partial<AuthStateData>): void;
+    /**
+     * Notify all subscribers of state change
+     *
+     * Requirements: 6.2
+     */
+    private notifySubscribers;
+    /**
+     * Subscribe to state changes
+     *
+     * Requirements: 6.2
+     *
+     * @param callback - Function to call when state changes
+     * @returns Unsubscribe function
+     */
+    subscribe(callback: StateChangeCallback): () => void;
+    /**
+     * Initialize state from stored authentication data
+     *
+     * Requirements: 6.1, 6.4
+     *
+     * @returns Promise that resolves when initialization is complete
+     */
+    initialize(): Promise<void>;
+    /**
+     * Logout and clear all authentication data
+     *
+     * Requirements: 6.3, 6.4
+     *
+     * @returns Promise that resolves when logout is complete
+     */
+    logout(): Promise<void>;
+}
+export {};

package/dist-types/services/contentExtractor.d.ts

@@ -0,0 +1,94 @@
+import { SanityDocument } from 'sanity';
+export interface DocumentContent {
+    documentId: string;
+    title: string;
+    htmlContent: string;
+}
+export interface ExtendedDocumentContent extends DocumentContent {
+    slug?: string;
+    /** Fields can be either flat values or TranslatableField objects with value and dnt properties */
+    fields?: Record<string, any>;
+}
+export interface ExtractedContent {
+    documentId: string;
+    documentType: string;
+    title: string;
+    htmlContent: string;
+    extractedAt: Date;
+}
+export declare class ContentExtractor {
+    /**
+     * Infer the Sanity field type from a value
+     *
+     * @param value - The field value to inspect
+     * @returns The inferred Sanity type string
+     */
+    private inferSanityType;
+    /**
+     * Extract content from a single Sanity document and convert to HTML
+     */
+    extractDocumentContent(document: SanityDocument): Promise<string>;
+    /**
+     * Convert Sanity document content to HTML format
+     */
+    convertToHtml(content: any): string;
+    /**
+     * Extract structured content with separated body, title, slug, and fields
+     * Also applies DNT preferences if available
+     */
+    extractStructuredContent(document: SanityDocument): Promise<ExtendedDocumentContent>;
+    /**
+     * Apply DNT preferences to extracted fields based on document type
+     * Now uses document-type-based configuration that applies to all documents of the same type
+     */
+    private applyDNTPreferences;
+    /**
+     * Extract content from multiple documents for bulk operations
+     */
+    extractBulkContent(documents: SanityDocument[]): Promise<DocumentContent[]>;
+    /**
+     * Extract structured content from multiple documents
+     */
+    extractBulkStructuredContent(documents: SanityDocument[]): Promise<ExtendedDocumentContent[]>;
+    /**
+     * Process individual fields based on their type
+     */
+    private processField;
+    /**
+     * Process array fields (like portable text blocks)
+     */
+    private processArray;
+    /**
+     * Process portable text blocks and convert to HTML
+     */
+    private processPortableTextBlock;
+    /**
+     * Extract content from portable text block children
+     */
+    private processPortableTextBlockContent;
+    /**
+     * Process object fields
+     */
+    private processObject;
+    /**
+     * Wrap content in HTML with field name as class
+     */
+    private wrapInHtml;
+    /**
+     * Separate main content from metadata fields
+     * All fields are immediately wrapped in TranslatableField format with type information
+     */
+    private separateContentAndFields;
+    /**
+     * Extract slug from document
+     */
+    private extractSlug;
+    /**
+     * Extract title from document
+     */
+    private extractTitle;
+    /**
+     * Escape HTML special characters
+     */
+    private escapeHtml;
+}

package/dist-types/services/dialogService.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Dialog management service with React state management
+ * Requirements: 3.1, 3.2, 3.5, 3.6, 3.7
+ *
+ * Centralized dialog management with queue support for multiple simultaneous dialogs
+ */
+import React, { ReactNode } from 'react';
+import type { DialogManager, ConfirmationDialogOptions, SuccessDialogOptions, ErrorDialogOptions, LocaleSelectionDialogOptions, LocaleSelectionResult } from '../types/dialog';
+/**
+ * Dialog types for queue management
+ */
+type DialogType = 'confirmation' | 'success' | 'error' | 'localeSelection';
+/**
+ * Dialog options union type
+ */
+type DialogOptions = ConfirmationDialogOptions | SuccessDialogOptions | ErrorDialogOptions | LocaleSelectionDialogOptions;
+/**
+ * Dialog queue item structure
+ */
+interface DialogQueueItem {
+    id: string;
+    type: DialogType;
+    options: DialogOptions;
+    resolve?: (value: unknown) => void;
+    reject?: (error: Error) => void;
+}
+/**
+ * Dialog context state
+ */
+interface DialogContextState {
+    currentDialog: DialogQueueItem | null;
+    dialogQueue: DialogQueueItem[];
+    showConfirmation: (options: ConfirmationDialogOptions) => Promise<boolean>;
+    showLocaleSelection: (options: LocaleSelectionDialogOptions) => Promise<LocaleSelectionResult>;
+    showSuccess: (options: SuccessDialogOptions) => void;
+    showError: (options: ErrorDialogOptions) => Promise<boolean>;
+    closeAll: () => void;
+}
+/**
+ * Hook to access dialog service from React components
+ */
+export declare const useDialogService: () => DialogContextState;
+/**
+ * Dialog Provider Props
+ */
+interface DialogProviderProps {
+    children: ReactNode;
+}
+/**
+ * Dialog Provider Component
+ * Manages dialog state and queue for the entire application
+ */
+export declare const DialogProvider: React.FC<DialogProviderProps>;
+/**
+ * Singleton DialogService class for non-React contexts
+ * Note: This requires the DialogProvider to be mounted in the React tree
+ */
+export declare class DialogService implements DialogManager {
+    private static instance;
+    private contextRef;
+    private constructor();
+    /**
+     * Get singleton instance
+     */
+    static getInstance(): DialogService;
+    /**
+     * Set the context reference (called by DialogProvider)
+     */
+    setContext(context: DialogContextState): void;
+    /**
+     * Show a confirmation dialog
+     */
+    showConfirmation(options: ConfirmationDialogOptions): Promise<boolean>;
+    /**
+     * Show a locale selection dialog
+     */
+    showLocaleSelection(options: LocaleSelectionDialogOptions): Promise<LocaleSelectionResult>;
+    /**
+     * Show a success notification
+     */
+    showSuccess(options: SuccessDialogOptions): void;
+    /**
+     * Show an error dialog
+     */
+    showError(options: ErrorDialogOptions): Promise<boolean>;
+    /**
+     * Close all open dialogs
+     */
+    closeAll(): void;
+}
+/**
+ * Export singleton instance for convenience
+ */
+export declare const dialogService: DialogService;
+export {};

package/dist-types/services/dntServiceManager.d.ts

@@ -0,0 +1,43 @@
+/**
+ * DNT Service Manager
+ *
+ * Provides singleton access to DNTStorageAdapter with proper initialization.
+ * Similar to OAuthServiceManager pattern.
+ */
+import { SanityClient } from 'sanity';
+import { DNTStorageAdapter } from './dntStorageAdapter';
+/**
+ * Singleton manager for DNT storage services
+ */
+export declare class DNTServiceManager {
+    private static instance;
+    private dntStorage;
+    private client;
+    private constructor();
+    /**
+     * Get or create the singleton instance
+     */
+    static getInstance(client?: SanityClient): DNTServiceManager;
+    /**
+     * Initialize the service with a Sanity client
+     */
+    initialize(client: SanityClient): void;
+    /**
+     * Get the DNT storage adapter
+     * Throws if not initialized
+     */
+    getDNTStorage(): DNTStorageAdapter;
+    /**
+     * Check if the service is initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * Reset the singleton instance (useful for testing)
+     */
+    static reset(): void;
+}
+/**
+ * Convenience function to get DNT storage adapter
+ * Throws if service is not initialized
+ */
+export declare function getDNTStorage(): DNTStorageAdapter;

package/dist-types/services/dntStorageAdapter.d.ts

@@ -0,0 +1,72 @@
+/**
+ * DNT (Do Not Translate) preferences storage adapter
+ *
+ * Now uses document-type-based storage in the unified configuration.
+ * When you mark a field as DNT for any document of a type (e.g., 'product'),
+ * it applies to ALL documents of that type.
+ *
+ * This replaces the old per-document localStorage approach with centralized
+ * configuration stored in Sanity.
+ */
+import { DNTPreferences, DNTStorage } from '../types/dnt';
+import { UnifiedConfigStorage } from './unifiedConfigStorage';
+/**
+ * DNT Storage Adapter using unified configuration
+ */
+export declare class DNTStorageAdapter implements DNTStorage {
+    private configStorage;
+    constructor(configStorage: UnifiedConfigStorage);
+    /**
+     * Get DNT field configuration for a document type
+     */
+    getFieldsForType(documentType: string): Promise<Record<string, boolean>>;
+    /**
+     * Set DNT status for a specific field in a document type
+     */
+    setFieldDNT(documentType: string, fieldPath: string, dnt: boolean): Promise<void>;
+    /**
+     * Toggle DNT status for a field in a document type
+     */
+    toggleFieldDNT(documentType: string, fieldPath: string): Promise<boolean>;
+    /**
+     * Get DNT status for a specific field in a document type
+     */
+    getFieldDNT(documentType: string, fieldPath: string): Promise<boolean>;
+    /**
+     * Clear all DNT fields for a document type
+     */
+    clearFieldsForType(documentType: string): Promise<void>;
+    /**
+     * Get all DNT configurations (all document types)
+     */
+    getAllDNTFields(): Promise<Record<string, Record<string, boolean>>>;
+    /**
+     * @deprecated Use getFieldsForType instead. This method now uses document type, not document ID.
+     * Get DNT preferences - now based on document type, not individual document ID
+     */
+    getPreferences(documentId: string): Promise<DNTPreferences | null>;
+    /**
+     * @deprecated Use setFieldDNT instead
+     */
+    savePreferences(preferences: DNTPreferences): Promise<void>;
+    /**
+     * @deprecated Use clearFieldsForType instead
+     */
+    clearPreferences(documentId: string): Promise<void>;
+}
+/**
+ * Legacy DNT Storage Adapter using localStorage (deprecated)
+ * Kept for migration purposes only
+ * @deprecated Use DNTStorageAdapter with UnifiedConfigStorage instead
+ */
+export declare class LegacyDNTStorageAdapter {
+    private static readonly STORAGE_KEY_PREFIX;
+    private getStorageKey;
+    getPreferences(documentId: string): Promise<DNTPreferences | null>;
+    savePreferences(preferences: DNTPreferences): Promise<void>;
+    clearPreferences(documentId: string): Promise<void>;
+    /**
+     * Migrate legacy localStorage preferences to unified configuration
+     */
+    migrateToUnified(configStorage: UnifiedConfigStorage, documentId: string, documentType: string): Promise<void>;
+}

package/dist-types/services/documentCreationService.d.ts

@@ -0,0 +1,138 @@
+import { SanityDocument, SanityClient } from 'sanity';
+import { TranslationResponse } from './translationService';
+/**
+ * Options for document creation from translation
+ */
+export interface DocumentCreationOptions {
+    /** Target language code for the translated document */
+    targetLanguage?: string;
+    /** Source language code of the original document */
+    sourceLanguage?: string;
+    /** Whether to create the document as a variant of the original */
+    createAsVariant?: boolean;
+    /** ID of the parent document when creating as a variant */
+    parentDocumentId?: string;
+    /** Creation mode: 'draft' creates a draft document, 'published' creates a published document */
+    creationMode?: 'draft' | 'published';
+}
+export interface DocumentCreationResult {
+    success: boolean;
+    documentId?: string;
+    document?: SanityDocument;
+    error?: string;
+}
+export interface BulkDocumentCreationResult {
+    totalDocuments: number;
+    successfulCreations: number;
+    failedCreations: number;
+    results: DocumentCreationResult[];
+    errors: string[];
+    rollbackInfo?: RollbackInfo;
+}
+export interface RollbackInfo {
+    canRollback: boolean;
+    createdDocumentIds: string[];
+    rollbackInstructions: string[];
+}
+export declare class DocumentCreationService {
+    private client;
+    private defaultCreationMode;
+    constructor(client: SanityClient, defaultCreationMode?: 'draft' | 'published');
+    /**
+     * Set the default document creation mode
+     * @param mode - The creation mode to use by default ('draft' or 'published')
+     */
+    setDefaultCreationMode(mode: 'draft' | 'published'): void;
+    /**
+     * Create a new Sanity document from translation response
+     * Requirements: 1.1, 1.2, 2.1, 3.2, 3.4
+     */
+    createDocumentFromTranslation(originalDocument: SanityDocument, translationResponse: TranslationResponse, options?: DocumentCreationOptions): Promise<DocumentCreationResult>;
+    /**
+     * Validate inputs for document creation
+     * Requirements: 4.3, 4.4
+     */
+    private validateInputsForDocumentCreation;
+    /**
+     * Validate business rules for document creation
+     * Requirements: 4.3, 4.4
+     */
+    private validateBusinessRules;
+    /**
+     * Check if document has meaningful content
+     */
+    private documentHasContent;
+    /**
+     * Format error messages with additional context
+     * Requirements: 4.3, 4.4
+     */
+    private formatErrorMessage;
+    /**
+     * Create multiple documents from bulk translation responses
+     * Requirements: 2.1, 3.2, 3.4
+     */
+    createBulkDocumentsFromTranslations(originalDocuments: SanityDocument[], translationResponses: TranslationResponse[], options?: DocumentCreationOptions): Promise<BulkDocumentCreationResult>;
+    /**
+     * Validate bulk translation responses before document creation
+     * Requirements: 4.3, 4.4
+     */
+    private validateBulkTranslationResponses;
+    /**
+     * Validate translation response before document creation
+     * Requirements: 4.3, 4.4
+     */
+    private validateTranslationResponseForCreation;
+    /**
+     * Create rollback plan for failed bulk operations
+     * Requirements: 4.3, 4.4
+     */
+    createRollbackPlan(createdDocumentIds: string[]): RollbackInfo;
+    /**
+     * Merge translated content back into original document structure
+     * Requirements: 1.2, 3.2, 3.4
+     */
+    private mergeTranslatedContent;
+    /**
+     * Process a translated field value and convert it to the appropriate format
+     * based on the original document's structure
+     */
+    private processTranslatedField;
+    /**
+     * Convert HTML content back to Sanity portable text format
+     * Requirements: 3.2, 3.4
+     */
+    private convertHtmlToPortableText;
+    /**
+     * Parse inline content and handle formatting
+     */
+    private parseInlineContent;
+    /**
+     * Get block style from HTML tag name
+     */
+    private getBlockStyle;
+    /**
+     * Check if content appears to be HTML
+     */
+    private isHtmlContent;
+    /**
+     * Generate a new document ID based on original ID and target language
+     */
+    private generateNewDocumentId;
+    /**
+     * Generate a unique key for portable text blocks
+     */
+    private generateBlockKey;
+    /**
+     * Generate a unique key for spans
+     */
+    private generateSpanKey;
+    /**
+     * Validate document structure before creation
+     * Requirements: 3.4
+     */
+    private validateDocumentStructure;
+    /**
+     * Validate portable text array structure
+     */
+    private validatePortableTextArray;
+}