@restnfeel/agentc-starter-kit/src/types/template-system.ts

한국어 기업용 CMS 모듈 - Task Master AI와 함께 빠르게 웹사이트를 구현할 수 있는 재사용 가능한 컴포넌트 시스템

/**
 * AgentC Template System Types
 * 서비스 티어별 템플릿 시스템의 핵심 타입 정의
 */

// 서비스 티어 정의
export enum ServiceTier {
  STARTER = "STARTER",
  STANDARD = "STANDARD",
  PLUS = "PLUS",
}

// 컴포넌트 타입 정의
export enum ComponentType {
  HEADER = "HEADER",
  HERO = "HERO",
  ABOUT = "ABOUT",
  SERVICES = "SERVICES",
  TESTIMONIALS = "TESTIMONIALS",
  PORTFOLIO = "PORTFOLIO",
  PRICING = "PRICING",
  FAQ = "FAQ",
  BLOG = "BLOG",
  CONTACT = "CONTACT",
  FOOTER = "FOOTER",
  TEAM = "TEAM",
  GALLERY = "GALLERY",
  NEWSLETTER = "NEWSLETTER",
  CASE_STUDIES = "CASE_STUDIES",
  SOCIAL = "SOCIAL",
}

// 컴포넌트 기본 인터페이스
export interface BaseComponent {
  id: string;
  type: ComponentType;
  title: string;
  description?: string;
  isRequired: boolean;
  availableIn: ServiceTier[];
  order: number;
  settings: ComponentSettings;
}

// 컴포넌트 설정
export interface ComponentSettings {
  [key: string]: unknown;
  enabled: boolean;
  visible: boolean;
  customizable: boolean;
}

// 템플릿 기본 인터페이스
export interface BaseTemplate {
  id: string;
  name: string;
  slug: string;
  tier: ServiceTier;
  description: string;
  components: BaseComponent[];
  globalSettings: GlobalTemplateSettings;
  customizationOptions: CustomizationOptions;
  metadata: TemplateMetadata;
}

// 글로벌 템플릿 설정
export interface GlobalTemplateSettings {
  theme: {
    primaryColor: string;
    secondaryColor: string;
    accentColor?: string;
    fontFamily: string;
    borderRadius: number;
  };
  layout: {
    containerWidth: "full" | "contained" | "narrow";
    spacing: "compact" | "normal" | "spacious";
    headerStyle: "simple" | "standard" | "advanced";
    footerStyle: "minimal" | "standard" | "comprehensive";
  };
  seo: {
    metaTitle?: string;
    metaDescription?: string;
    ogImage?: string;
    structuredData?: boolean;
  };
  performance: {
    lazyLoading: boolean;
    cacheStrategy: "none" | "basic" | "aggressive";
    optimizeImages: boolean;
  };
  customProperties?: {
    [key: string]: unknown;
    features?: string[];
    tier?: ServiceTier;
    maxComponents?: number;
    advancedCustomization?: boolean;
    prioritySupport?: boolean;
    whiteLabel?: unknown;
    i18n?: unknown;
    ecommerce?: unknown;
    analytics?: unknown;
  };
}

// 커스터마이제이션 옵션
export interface CustomizationOptions {
  colors: {
    allowCustomColors: boolean;
    predefinedPalettes: string[][];
    maxCustomColors?: number;
  };
  typography: {
    allowFontChange: boolean;
    availableFonts: string[];
    allowFontSizeChange: boolean;
  };
  layout: {
    allowLayoutChange: boolean;
    availableLayouts: string[];
    allowComponentReordering: boolean;
  };
  components: {
    allowComponentToggle: boolean;
    allowComponentSettings: boolean;
    restrictedComponents: ComponentType[];
  };
  advanced: {
    allowCustomCSS: boolean;
    allowCustomJS: boolean;
    allowThirdPartyIntegrations: boolean;
  };
}

// 템플릿 메타데이터
export interface TemplateMetadata {
  version: string;
  lastModified: Date;
  author: string;
  category: string;
  tags: string[];
  previewImages: string[];
  demoUrl?: string;
  documentation?: string;
  minimumTier: ServiceTier;
  features: string[];
  compatibility: {
    browsers: string[];
    devices: string[];
    frameworks: string[];
  };
}

// 컴포넌트 렌더링 설정
export interface ComponentRenderConfig {
  component: BaseComponent;
  props: Record<string, unknown>;
  children?: ComponentRenderConfig[];
  conditionalRender?: {
    condition: string;
    fallback?: ComponentRenderConfig;
  };
}

// 템플릿 렌더링 설정
export interface TemplateRenderConfig {
  template: BaseTemplate;
  components: ComponentRenderConfig[];
  globalProps: Record<string, unknown>;
  context: TemplateContext;
}

// 템플릿 컨텍스트
export interface TemplateContext {
  siteData: {
    id: string;
    name: string;
    domain: string;
    tier: ServiceTier;
  };
  userData: {
    id: string;
    name: string;
    role: string;
    permissions: string[];
  };
  content: Record<string, unknown>;
  settings: Record<string, unknown>;
}

// 컴포넌트 레지스트리 인터페이스
export interface ComponentRegistry {
  register(component: ComponentDefinition): void;
  get(type: ComponentType, tier: ServiceTier): ComponentDefinition | null;
  getAvailable(tier: ServiceTier): ComponentDefinition[];
  validate(component: BaseComponent, tier: ServiceTier): boolean;
}

// 컴포넌트 정의
export interface ComponentDefinition {
  type: ComponentType;
  name: string;
  description: string;
  tier: ServiceTier;
  component: React.ComponentType<unknown>;
  defaultSettings: ComponentSettings;
  schema: ComponentSchema;
  preview?: React.ComponentType<unknown>;
}

// 컴포넌트 스키마 (설정 검증용)
export interface ComponentSchema {
  type: "object";
  properties: Record<string, SchemaProperty>;
  required: string[];
  additionalProperties: boolean;
}

export interface SchemaProperty {
  type: "string" | "number" | "boolean" | "array" | "object";
  description: string;
  default?: unknown;
  enum?: unknown[];
  items?: SchemaProperty;
  properties?: Record<string, SchemaProperty>;
}

// 템플릿 팩토리 인터페이스
export interface TemplateFactory {
  create(tier: ServiceTier, config: Partial<BaseTemplate>): BaseTemplate;
  clone(template: BaseTemplate): BaseTemplate;
  migrate(template: BaseTemplate, newTier: ServiceTier): BaseTemplate;
  validate(template: BaseTemplate): TemplateValidationResult;
}

// 템플릿 검증 결과
export interface TemplateValidationResult {
  isValid: boolean;
  errors: TemplateValidationError[];
  warnings: TemplateValidationWarning[];
}

export interface TemplateValidationError {
  code: string;
  message: string;
  component?: string;
  severity: "error" | "warning";
}

export interface TemplateValidationWarning {
  code: string;
  message: string;
  component?: string;
  suggestion?: string;
}

// 템플릿 매니저 인터페이스
export interface TemplateManager {
  getTemplate(id: string): Promise<BaseTemplate | null>;
  saveTemplate(template: BaseTemplate): Promise<void>;
  deleteTemplate(id: string): Promise<void>;
  listTemplates(tier?: ServiceTier): Promise<BaseTemplate[]>;
  applyTemplate(siteId: string, templateId: string): Promise<void>;
  migrateContent(fromTemplate: string, toTemplate: string): Promise<void>;
}