@json-to-office/jto 0.1.0

package/dist/client/templates/themes/corporate.pptx.theme.json

@@ -0,0 +1,32 @@
+{
+  "name": "corporate",
+  "colors": {
+    "primary": "#1a365d",
+    "secondary": "#2D3748",
+    "accent": "#3182CE",
+    "background": "#F7FAFC",
+    "text": "#1A202C",
+    "text2": "#4A5568",
+    "background2": "#EDF2F7",
+    "accent4": "#E53E3E",
+    "accent5": "#38A169",
+    "accent6": "#D69E2E"
+  },
+  "fonts": {
+    "heading": "Arial",
+    "body": "Arial"
+  },
+  "defaults": {
+    "fontSize": 14,
+    "fontColor": "#1A202C"
+  },
+  "styles": {
+    "title": { "fontSize": 44, "bold": true, "fontColor": "text", "align": "center" },
+    "subtitle": { "fontSize": 20, "italic": true, "fontColor": "text2", "align": "center" },
+    "heading1": { "fontSize": 28, "bold": true, "fontColor": "primary" },
+    "heading2": { "fontSize": 22, "bold": true, "fontColor": "primary" },
+    "heading3": { "fontSize": 18, "bold": true, "fontColor": "text" },
+    "body": { "fontSize": 14 },
+    "caption": { "fontSize": 10, "italic": true, "fontColor": "text2" }
+  }
+}

package/dist/client/templates/themes/minimal.pptx.theme.json

@@ -0,0 +1,32 @@
+{
+  "name": "minimal",
+  "colors": {
+    "primary": "#1F2937",
+    "secondary": "#6B7280",
+    "accent": "#3B82F6",
+    "background": "#FFFFFF",
+    "text": "#1F2937",
+    "text2": "#9CA3AF",
+    "background2": "#F3F4F6",
+    "accent4": "#EF4444",
+    "accent5": "#10B981",
+    "accent6": "#F59E0B"
+  },
+  "fonts": {
+    "heading": "Inter",
+    "body": "Inter"
+  },
+  "defaults": {
+    "fontSize": 16,
+    "fontColor": "#1F2937"
+  },
+  "styles": {
+    "title": { "fontSize": 36, "bold": true, "fontColor": "text", "align": "center" },
+    "subtitle": { "fontSize": 18, "italic": true, "fontColor": "text2", "align": "center" },
+    "heading1": { "fontSize": 28, "bold": true, "fontColor": "primary" },
+    "heading2": { "fontSize": 22, "bold": true, "fontColor": "primary" },
+    "heading3": { "fontSize": 18, "bold": true, "fontColor": "text" },
+    "body": { "fontSize": 14 },
+    "caption": { "fontSize": 10, "italic": true, "fontColor": "text2" }
+  }
+}

package/dist/client/templates/themes/vibrant.pptx.theme.json

@@ -0,0 +1,32 @@
+{
+  "name": "vibrant",
+  "colors": {
+    "primary": "#7C3AED",
+    "secondary": "#2563EB",
+    "accent": "#059669",
+    "background": "#0F172A",
+    "text": "#F8FAFC",
+    "text2": "#94A3B8",
+    "background2": "#1E293B",
+    "accent4": "#F59E0B",
+    "accent5": "#EC4899",
+    "accent6": "#06B6D4"
+  },
+  "fonts": {
+    "heading": "Helvetica",
+    "body": "Helvetica"
+  },
+  "defaults": {
+    "fontSize": 16,
+    "fontColor": "#F8FAFC"
+  },
+  "styles": {
+    "title": { "fontSize": 44, "bold": true, "fontColor": "text", "align": "center" },
+    "subtitle": { "fontSize": 18, "italic": true, "fontColor": "text2", "align": "center" },
+    "heading1": { "fontSize": 32, "bold": true, "fontColor": "text" },
+    "heading2": { "fontSize": 24, "bold": true, "fontColor": "primary" },
+    "heading3": { "fontSize": 18, "bold": true, "fontColor": "text" },
+    "body": { "fontSize": 14 },
+    "caption": { "fontSize": 10, "italic": true, "fontColor": "text2" }
+  }
+}

package/dist/index.d.ts

@@ -0,0 +1,387 @@
+import * as _sinclair_typebox from '@sinclair/typebox';
+import { TSchema, Static } from '@sinclair/typebox';
+
+type FormatName = 'docx' | 'pptx';
+interface GeneratorOptions {
+    theme?: string | any;
+    themePath?: string;
+    customThemes?: Record<string, any>;
+    validation?: {
+        strict?: boolean;
+        allowUnknownFields?: boolean;
+    };
+}
+interface GeneratorResult {
+    generateBuffer: (document: any) => Promise<Buffer>;
+    getStandardComponentsDefinition?: (config: any) => Promise<any>;
+    hasPlugins: boolean;
+    pluginNames: string[];
+}
+interface FormatAdapter {
+    name: FormatName;
+    extension: string;
+    label: string;
+    defaultPort: number;
+    generateBuffer(json: unknown, options: GeneratorOptions): Promise<Buffer>;
+    createGenerator(plugins: any[], options: GeneratorOptions): Promise<GeneratorResult>;
+    parseJson(input: string | object): unknown;
+    validateDocument(doc: unknown): {
+        valid: boolean;
+        errors?: any[];
+    };
+    generateSchema(options?: any): any;
+    getBuiltinThemes(): Record<string, any>;
+    resolveTheme(options: GeneratorOptions): Promise<any>;
+    loadCustomThemes(options: GeneratorOptions): Promise<Record<string, any> | undefined>;
+    getComponentCacheStats?(): Promise<any>;
+    getComponentCacheAnalytics?(): Promise<any>;
+}
+declare class DocxFormatAdapter implements FormatAdapter {
+    name: FormatName;
+    extension: string;
+    label: string;
+    defaultPort: number;
+    generateBuffer(json: unknown, options: GeneratorOptions): Promise<Buffer>;
+    createGenerator(plugins: any[], options: GeneratorOptions): Promise<GeneratorResult>;
+    parseJson(input: string | object): unknown;
+    validateDocument(_doc: unknown): {
+        valid: boolean;
+        errors?: any[];
+    };
+    generateSchema(_options?: any): any;
+    getBuiltinThemes(): Record<string, any>;
+    resolveTheme(options: GeneratorOptions): Promise<any>;
+    loadCustomThemes(options: GeneratorOptions): Promise<Record<string, any> | undefined>;
+    getComponentCacheStats(): Promise<any>;
+    getComponentCacheAnalytics(): Promise<any>;
+}
+declare class PptxFormatAdapter implements FormatAdapter {
+    name: FormatName;
+    extension: string;
+    label: string;
+    defaultPort: number;
+    generateBuffer(json: unknown, options: GeneratorOptions): Promise<Buffer>;
+    createGenerator(plugins: any[], options: GeneratorOptions): Promise<GeneratorResult>;
+    parseJson(input: string | object): unknown;
+    validateDocument(_doc: unknown): {
+        valid: boolean;
+        errors?: any[];
+    };
+    generateSchema(_options?: any): any;
+    getBuiltinThemes(): Record<string, any>;
+    resolveTheme(options: GeneratorOptions): Promise<any>;
+    loadCustomThemes(options: GeneratorOptions): Promise<Record<string, any> | undefined>;
+}
+declare function createAdapter(format: FormatName): FormatAdapter;
+
+type ComponentDefinition = any;
+declare class GeneratorFactory {
+    private registry;
+    private adapter;
+    constructor(adapter: FormatAdapter);
+    createGenerator(options?: GeneratorOptions): Promise<{
+        generateBuffer: (document: ComponentDefinition | string) => Promise<Buffer>;
+        hasPlugins: boolean;
+        pluginNames: string[];
+    }>;
+    generate(document: ComponentDefinition | string, options?: GeneratorOptions): Promise<Buffer>;
+    getPluginInfo(): {
+        hasPlugins: boolean;
+        count: number;
+        names: string[];
+    };
+}
+
+interface CustomComponent {
+    name: string;
+    versions?: Record<string, any>;
+    [key: string]: any;
+}
+declare class PluginLoader {
+    private tsxUnregister?;
+    initialize(): Promise<void>;
+    loadPlugin(filePath: string): Promise<CustomComponent | null>;
+    loadPlugins(filePaths: string[]): Promise<Map<string, CustomComponent>>;
+    private extractComponent;
+    private isValidComponent;
+    cleanup(): void;
+}
+
+interface PluginExample {
+    title?: string;
+    props: any;
+    description?: string;
+}
+interface PluginMetadata {
+    name: string;
+    description?: string;
+    version?: string;
+    filePath: string;
+    relativePath: string;
+    location: 'upstream' | 'downstream' | 'current';
+    hasChildren?: boolean;
+    schema: {
+        raw: TSchema;
+        jsonSchema?: any;
+        properties?: Record<string, any>;
+    };
+    examples?: PluginExample[];
+}
+declare class PluginMetadataExtractor {
+    private cwd;
+    constructor(cwd?: string);
+    extract(component: CustomComponent, filePath: string): Promise<PluginMetadata>;
+    private determineLocation;
+    private typeboxToJsonSchema;
+    private extractProperties;
+    private extractExamples;
+    extractBatch(components: Map<string, CustomComponent>): Promise<PluginMetadata[]>;
+}
+
+declare class PluginRegistry {
+    private static instance;
+    private plugins;
+    private pluginPaths;
+    private pluginMetadata;
+    private loader;
+    private discoveryService;
+    private constructor();
+    static getInstance(): PluginRegistry;
+    private notifyCacheInvalidation;
+    loadPlugin(pathOrName: string): Promise<void>;
+    loadPlugins(pathsOrNames: string[]): Promise<void>;
+    private loadPluginsFromMetadata;
+    loadPluginsFromDirectory(dir: string): Promise<number>;
+    discoverAndLoad(): Promise<{
+        discovered: number;
+        loaded: number;
+    }>;
+    resolvePluginName(name: string): Promise<string | undefined>;
+    private resolvePluginPath;
+    getPlugins(): CustomComponent[];
+    getPluginNames(): string[];
+    getPlugin(name: string): CustomComponent | undefined;
+    hasPlugins(): boolean;
+    getPluginCount(): number;
+    clear(): void;
+    static cleanup(): void;
+    getPluginMetadata(name: string): PluginMetadata | undefined;
+    getAllPluginMetadata(): PluginMetadata[];
+}
+
+declare class PluginResolver {
+    private discoveryService;
+    private discoveredPlugins;
+    private lastDiscoveryTime;
+    private readonly CACHE_DURATION;
+    constructor();
+    resolve(input: string): Promise<string>;
+    resolveMultiple(inputs: string[]): Promise<Map<string, string>>;
+    private resolveAsPath;
+    private resolveAsName;
+    private refreshDiscoveryCache;
+    private isCacheExpired;
+    private looksLikePath;
+    private createNotFoundError;
+    private findSimilarNames;
+    getAvailablePluginNames(): Promise<string[]>;
+    clearCache(): void;
+}
+
+type DiscoveryType = 'plugin' | 'docx-document' | 'pptx-document' | 'pptx-theme' | 'docx-theme';
+
+interface DiscoverOptions {
+    scope?: string;
+    maxDepth?: number;
+    includeNodeModules?: boolean;
+    verbose?: boolean;
+    type?: DiscoveryType | 'all';
+}
+interface DocumentMetadata {
+    name: string;
+    path: string;
+    location: 'current' | 'downstream';
+    type?: string;
+    title?: string;
+    description?: string;
+    theme?: string;
+}
+interface ThemeMetadata {
+    name: string;
+    path: string;
+    location: 'current' | 'downstream';
+    description?: string;
+}
+declare class PluginDiscoveryService {
+    private scanner;
+    private loader;
+    private metadataExtractor;
+    private options;
+    private searchPath;
+    private projectRoot;
+    constructor(options?: DiscoverOptions);
+    discover(): Promise<PluginMetadata[]>;
+    discoverPlugins(): Promise<PluginMetadata[]>;
+    discoverDocuments(format?: 'docx' | 'pptx'): Promise<DocumentMetadata[]>;
+    discoverThemes(format: 'docx' | 'pptx'): Promise<ThemeMetadata[]>;
+    getDocumentContent(name: string, format?: 'docx' | 'pptx'): Promise<string>;
+    getThemeContent(name: string, format: 'docx' | 'pptx'): Promise<string>;
+    discoverAll(format: 'docx' | 'pptx'): Promise<{
+        plugins: PluginMetadata[];
+        documents: DocumentMetadata[];
+        themes: ThemeMetadata[];
+    }>;
+    private getFileLocation;
+    private searchDownstream;
+    hasPlugins(): Promise<boolean>;
+    getPluginByName(name: string): Promise<PluginMetadata | undefined>;
+}
+
+interface SchemaGenerateOptions {
+    includeDocument?: boolean;
+    includeTheme?: boolean;
+    split?: boolean;
+    format?: 'json' | 'typebox';
+}
+interface SchemaGenerateResults {
+    document?: string;
+    theme?: string;
+    components?: string[];
+}
+declare class SchemaGenerator {
+    private registry;
+    private typeboxExporter;
+    private formatName;
+    constructor(formatName?: FormatName);
+    generateAndExportSchemas(outputDir: string, options?: SchemaGenerateOptions): Promise<SchemaGenerateResults>;
+    private generateDocumentSchema;
+    private generateThemeSchema;
+    private generateComponentSchemas;
+    private getStandardComponentSchemas;
+    private getCustomComponents;
+}
+
+interface ValidationError {
+    path: string;
+    message: string;
+    code?: string;
+    line?: number;
+    column?: number;
+    suggestion?: string;
+    value?: any;
+}
+interface ValidateFileResult {
+    file: string;
+    valid: boolean;
+    type?: 'document' | 'theme' | 'custom';
+    errors?: ValidationError[];
+    warnings?: ValidationError[];
+}
+interface ValidateOptions {
+    type?: 'document' | 'theme' | 'auto';
+    schema?: string;
+    strict?: boolean;
+    recursive?: boolean;
+}
+declare class JsonValidator {
+    private format;
+    constructor(format?: FormatName);
+    validate(pathOrPattern: string, options?: ValidateOptions): Promise<ValidateFileResult[]>;
+    validateFile(filePath: string, options?: ValidateOptions): Promise<ValidateFileResult>;
+    private validateAsDocument;
+    private validateAsTheme;
+    private validateWithCustomSchema;
+    private detectType;
+    private getFilesToValidate;
+    formatError(error: ValidationError, indent?: number): string;
+    formatResultsAsJson(results: ValidateFileResult[]): string;
+}
+
+interface PluginConfig {
+    plugins?: string[];
+    pluginDirs?: string[];
+    autoDiscover?: boolean;
+    aliases?: Record<string, string>;
+    theme?: string | any;
+    themePath?: string;
+    discovery?: {
+        maxDepth?: number;
+        includeNodeModules?: boolean;
+        upstreamOnly?: boolean;
+        downstreamOnly?: boolean;
+    };
+    validation?: {
+        strict?: boolean;
+        allowUnknownFields?: boolean;
+    };
+}
+declare class PluginConfigService {
+    private static instance;
+    private config;
+    private configPath;
+    private static readonly CONFIG_FILES;
+    private constructor();
+    static getInstance(): PluginConfigService;
+    loadConfig(startPath?: string): Promise<PluginConfig | null>;
+    private loadFromPackageJson;
+    getConfig(): PluginConfig | null;
+    getConfigPath(): string | null;
+    mergeWithOptions(options: Partial<PluginConfig>): PluginConfig;
+    private mergeArrays;
+    resolveAlias(name: string): string;
+    getConfiguredPlugins(): string[];
+    getPluginDirectories(): string[];
+    isAutoDiscoverEnabled(): boolean;
+    saveConfig(config: PluginConfig, filePath?: string): Promise<void>;
+    createDefaultConfig(filePath?: string): Promise<void>;
+    clearConfig(): void;
+}
+
+declare const ConfigSchema: _sinclair_typebox.TObject<{
+    mode: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"development">, _sinclair_typebox.TLiteral<"production">]>;
+    server: _sinclair_typebox.TObject<{
+        port: _sinclair_typebox.TNumber;
+        host: _sinclair_typebox.TString;
+        cors: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+            origin: _sinclair_typebox.TUnion<[_sinclair_typebox.TString, _sinclair_typebox.TArray<_sinclair_typebox.TString>]>;
+            credentials: _sinclair_typebox.TBoolean;
+        }>>;
+    }>;
+    api: _sinclair_typebox.TObject<{
+        basePath: _sinclair_typebox.TString;
+        rateLimit: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+            windowMs: _sinclair_typebox.TNumber;
+            max: _sinclair_typebox.TNumber;
+        }>>;
+        upload: _sinclair_typebox.TObject<{
+            maxFileSize: _sinclair_typebox.TNumber;
+            allowedMimeTypes: _sinclair_typebox.TArray<_sinclair_typebox.TString>;
+        }>;
+    }>;
+    playground: _sinclair_typebox.TObject<{
+        enabled: _sinclair_typebox.TBoolean;
+        root: _sinclair_typebox.TString;
+        features: _sinclair_typebox.TObject<{
+            livePreview: _sinclair_typebox.TBoolean;
+            templateLibrary: _sinclair_typebox.TBoolean;
+            componentBuilder: _sinclair_typebox.TBoolean;
+            collaboration: _sinclair_typebox.TBoolean;
+        }>;
+    }>;
+    development: _sinclair_typebox.TObject<{
+        hmr: _sinclair_typebox.TBoolean;
+        hmrPort: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
+        sourceMap: _sinclair_typebox.TBoolean;
+        verbose: _sinclair_typebox.TBoolean;
+    }>;
+    paths: _sinclair_typebox.TObject<{
+        templates: _sinclair_typebox.TString;
+        modules: _sinclair_typebox.TString;
+        cache: _sinclair_typebox.TString;
+    }>;
+}>;
+type Config = Static<typeof ConfigSchema>;
+
+declare function loadConfig(configPath?: string): Promise<Config>;
+
+export { type Config, type CustomComponent, type DiscoverOptions, type DocumentMetadata, DocxFormatAdapter, type FormatAdapter, type FormatName, GeneratorFactory, type GeneratorOptions, type GeneratorResult, JsonValidator, type PluginConfig, PluginConfigService, PluginDiscoveryService, type PluginExample, PluginLoader, type PluginMetadata, PluginMetadataExtractor, PluginRegistry, PluginResolver, PptxFormatAdapter, type SchemaGenerateOptions, type SchemaGenerateResults, SchemaGenerator, type ThemeMetadata, type ValidateFileResult, type ValidateOptions, type ValidationError, createAdapter, loadConfig };