서문: 왜 프론트엔드 프레임워크를 만드는가?

📖 웹 프론트엔드 프레임워크 설계와 구현: SPA 개발을 위한 프론트엔드 아키텍처

제1장: 프레임워크의 시작점 - SimpleBootFront와 옵션

1.1. SimpleBootFront의 역할과 초기화
1.2. SimFrontOption을 통한 설정 관리
1.3. 의존성 주입(DI) 컨테이너 연동

제2장: 컴포넌트 시스템 - UI 구성의 핵심

2.1. @Component 데코레이터와 컴포넌트 정의
2.2. dom-render와의 통합
2.3. 컴포넌트 생명주기

제3장: 라우팅과 내비게이션 - SPA의 흐름 제어

3.1. @Router와 @Route를 활용한 라우팅

제4장: 동적 스크립트와 서비스 - 프레임워크 확장

4.1. @Script 데코레이터와 동적 스크립트
4.2. 내장 서비스 활용 (Cookie, Storage, MetaTag)
4.3. 커스텀 서비스 개발

제5장: 프레임워크의 기반 - Simple-Boot Core 연동

5.1. Simple-Boot Core의 DI, AOP, 예외 처리 활용
5.2. 프론트엔드 환경에 최적화된 통합

부록: 더 나아가기

A. Simple-Boot-Front 아키텍처의 장단점
B. 성능 최적화 및 확장 방안
C. 프론트엔드 프레임워크 개발의 미래

서문: 왜 프론트엔드 프레임워크를 만드는가?

현대 웹 개발에서 프론트엔드 프레임워크는 복잡한 사용자 인터페이스를 효율적으로 구축하는 데 필수적인 도구입니다. React, Angular, Vue와 같은 거대한 프레임워크들이 시장을 지배하고 있지만, 이 책은 그들의 사용법을 넘어 프론트엔드 프레임워크가 어떻게 설계되고 구현되는지 그 본질을 탐구하고자 합니다.

우리가 함께 해부할 프레임워크는 @dooboostore/simple-boot-front입니다. 이 프레임워크는 @dooboostore/simple-boot (DI, AOP, 라우팅 등 백엔드/코어 기능)과 @dooboostore/dom-render (반응형 UI 렌더링)를 기반으로 하여, SPA(Single Page Application) 개발에 필요한 모든 기능을 제공합니다.

이 책의 목표는 독자 여러분이 simple-boot-front의 내부 동작 원리를 이해하고, 나아가 자신만의 프론트엔드 프레임워크를 설계하고 구축할 수 있는 깊이 있는 지식과 통찰력을 얻도록 돕는 것입니다.

`simple-boot-front`의 핵심 특징

모듈화된 아키텍처: simple-boot의 강력한 DI 컨테이너와 AOP 기능을 활용하여 코드의 모듈성과 재사용성을 극대화합니다.
반응형 UI: dom-render를 통해 선언적인 HTML 템플릿과 JavaScript Proxy 기반의 반응성으로 효율적인 UI 업데이트를 제공합니다.
SPA 최적화: 클라이언트 측 라우팅, 컴포넌트 기반 개발, 동적 스크립트 로딩 등을 통해 SPA 개발에 최적화된 환경을 제공합니다.
선언적 개발: 데코레이터와 HTML 속성을 활용하여 직관적이고 선언적인 방식으로 애플리케이션을 구축할 수 있습니다.

이 책에서 다룰 주요 내용

프레임워크의 시작점: SimpleBootFront의 초기화 과정과 설정 관리.
컴포넌트 시스템: @Component 데코레이터와 dom-render를 활용한 UI 컴포넌트 구축.
라우팅과 내비게이션: SPA의 흐름을 제어하는 클라이언트 측 라우팅 구현.
동적 스크립트와 서비스: 프레임워크의 기능을 확장하고 재사용 가능한 유틸리티를 제공하는 방법.
Simple-Boot Core 연동: 백엔드/코어 프레임워크의 기능들을 프론트엔드 환경에서 어떻게 활용하는지.

이 여정을 통해 여러분은 프론트엔드 프레임워크 개발의 복잡한 세계를 탐험하고, 웹 애플리케이션 아키텍처에 대한 깊이 있는 이해를 얻게 될 것입니다. 이제, Simple-Boot-Front의 설계와 구현 여정을 시작해 봅시다.

제1장: 프레임워크의 시작점 - SimpleBootFront와 옵션

모든 프레임워크는 애플리케이션의 시작을 알리고 전반적인 설정을 관리하는 진입점(Entry Point)을 가집니다. Simple-Boot-Front에서는 SimpleBootFront 클래스가 이 역할을 담당합니다. 이 장에서는 SimpleBootFront의 초기화 과정과 SimFrontOption을 통한 설정 관리, 그리고 핵심 의존성 주입(DI) 컨테이너와의 연동에 대해 알아봅니다.

1.1. SimpleBootFront의 역할과 초기화

SimpleBootFront는 SimpleApplication (Simple-Boot Core의 핵심 클래스)을 상속받아 프론트엔드 환경에 특화된 기능을 추가합니다. 주요 역할은 다음과 같습니다.

프론트엔드 환경 설정: 브라우저 window 객체를 기반으로 프론트엔드 환경을 초기화합니다.
dom-render 통합: UI 렌더링을 담당하는 dom-render 라이브러리와 연동하여 반응형 UI를 구축합니다.
라우터 초기화: 클라이언트 측 라우팅을 위한 PathRouter 또는 HashRouter를 설정합니다.
핵심 서비스 등록: CookieService, StorageService, MetaTagService 등 프론트엔드 개발에 필요한 유틸리티 서비스들을 DI 컨테이너에 등록합니다.

SimpleBootFront 인스턴스는 new SimpleBootFront(option) 형태로 생성되며, run() 메소드를 호출하여 애플리케이션을 시작합니다.

// SimpleBootFront.ts (개념적)
export class SimpleBootFront extends SimpleApplication {
  public domRenderConfig: RunConfig;
  private domRenderRouter: Router | undefined;

  constructor(public option: SimFrontOption) {
    super(option);
    
    // 라우터 초기화 (HashRouter 또는 PathRouter)
    this.domRenderRouter = option.urlType === 'path' ? new PathRouter({window: option.window, disableAttach: true}) : new HashRouter({window: option.window, disableAttach: true});
    this.simstanceManager.setStoreSet(Router, this.domRenderRouter); // DI 컨테이너에 라우터 등록

    // dom-render 설정 초기화
    this.domRenderConfig = {
      window: option.window,
      targetElements: this.domRenderTargetElements, // 컴포넌트 등록용
      targetAttrs: this.domRenderTargetAttrs,     // 커스텀 속성 등록용
      routerType: this.domRenderRouter,           // dom-render에 라우터 주입
      scripts: { /* 동적 스크립트 등록용 */ },
      eventVariables: { /* 이벤트 핸들러에 주입될 변수 */ },
      proxyExcludeTyps: this.domRendoerExcludeProxy, // dom-render 프록시 제외 타입
      // ... 기타 설정 ...
    };

    // SimpleApplication의 프록시 핸들러에 dom-render 프록시 생성 로직 연결
    option.proxy = {
      onProxy: (it: any) => this.createDomRender(it) // @Sim 객체 생성 시 dom-render 프록시 적용
    };
  }

  public run(otherInstanceSim?: Map<ConstructorType<any>, any>, url?: string) {
    const simstanceManager = this.initRun(otherInstanceSim); // SimpleApplication의 초기화 로직 실행
    this.initDomRenderScripts(); // dom-render 스크립트 초기화
    this.initDomRenderTargetElements(); // dom-render 컴포넌트 초기화

    // 루트 라우터 초기 렌더링 및 popstate 이벤트 리스너 등록
    this.option.window.dispatchEvent(new Event('popstate'));
    return simstanceManager;
  }

  // ... createDomRender, initDomRenderScripts, initDomRenderTargetElements 등 내부 메소드 ...
}

1.2. SimFrontOption을 통한 설정 관리

SimFrontOption 클래스는 SimpleBootFront의 동작을 설정하는 데 사용됩니다. SimpleApplication의 SimOption을 상속받아 프론트엔드 특화된 설정들을 추가합니다.

selector: SimpleBootFront가 애플리케이션을 마운트할 DOM 엘리먼트의 CSS 셀렉터 (기본값: #app).
urlType: 라우팅 방식 ( UrlType.path 또는 UrlType.hash).
window: 브라우저의 window 객체. 테스트 환경 등에서 모의(mock) 객체를 주입할 때 유용합니다.
rootRouter: 애플리케이션의 최상위 라우터 클래스.

// option/SimFrontOption.ts
export enum UrlType {
  path = 'path',
  hash = 'hash'
}

export class SimFrontOption extends SimOption {
  selector: string = '#app';
  urlType: UrlType = UrlType.path;

  constructor(public window: Window, initSimOption?: InitOptionType) {
    super(initSimOption);
  }

  // 체이닝 가능한 설정 메소드
  setSelector(selector: string): SimFrontOption { this.selector = selector; return this; }
  setUrlType(urlType: UrlType): SimFrontOption { this.urlType = urlType; return this; }
  setRootRouter(rootRouter: ConstructorType<any>): SimFrontOption { this.rootRouter = rootRouter; return this; }
}

예제: `SimpleBootFront` 초기화 및 설정

SimpleBootFront를 초기화하고 라우터를 설정하는 전체 예제입니다. 이 예제는 quick-start에서 사용된 라우팅 방식을 따릅니다.

먼저, 페이지 컴포넌트와 라우터 컴포넌트의 템플릿 및 스타일을 별도 파일로 정의합니다.

./home-page.component.html

<div>Home Page</div>

./about-page.component.html

<div>About Page</div>

./app-router.component.html

<nav>
  <button dr-event-click="$router?.go({path: '/'})">Home</button>
  <button dr-event-click="$router?.go({path: '/about'})">About</button>
</nav>
<main>
  <div dr-this="@this@.child"></div> <!-- 라우팅된 컴포넌트가 렌더링될 위치 -->
</main>

./app-router.component.css

nav button { 
  margin-right: 10px; 
  padding: 5px 10px; 
}
main { 
  border: 1px solid #ccc; 
  padding: 20px; 
  margin-top: 20px; 
}

이제 이 파일들을 사용하여 전체 예제 코드를 작성합니다.

import 'reflect-metadata';
import { SimpleBootFront } from '@dooboostore/simple-boot-front/SimpleBootFront';
import { SimFrontOption, UrlType } from '@dooboostore/simple-boot-front/option/SimFrontOption';
import { Sim } from '@dooboostore/simple-boot/decorators/SimDecorator';
import { Router } from '@dooboostore/simple-boot/decorators/route/Router';
import { Component } from '@dooboostore/simple-boot-front/decorators/Component';
import { RouterAction } from '@dooboostore/simple-boot/route/RouterAction';
import { ComponentSet } from '@dooboostore/simple-boot-front/component/ComponentSet';

// 템플릿 및 스타일 파일 임포트
import homeTemplate from './home-page.component.html';
import aboutTemplate from './about-page.component.html';
import appRouterTemplate from './app-router.component.html';
import appRouterStyles from './app-router.component.css';

// 1. 페이지 컴포넌트 정의
@Sim
@Component({ template: homeTemplate })
class HomePage {}

@Sim
@Component({ template: aboutTemplate })
class AboutPage {}

// 2. 라우터 정의
@Sim
@Router({
    path: '', // 루트 경로
    route: {
        '/': HomePage,
        '/about': AboutPage
    }
})
@Component({ 
  template: appRouterTemplate,
  styles: appRouterStyles
})
export class AppRouter implements RouterAction {
  child?: ComponentSet<any>; // 라우팅된 컴포넌트를 ComponentSet으로 관리

  // 라우팅 가드: 라우팅되기 전에 호출
  async canActivate(url: any, module: any) {
    this.child = new ComponentSet(module); // 라우팅된 모듈을 ComponentSet으로 감싸서 할당
    console.log(`Navigating to: ${url.intent.pathname}, Module: ${module?.constructor.name}`);
  }
}

// 3. SimpleBootFront 인스턴스 생성 및 설정
const config = new SimFrontOption(window) // 브라우저 window 객체 주입
  .setRootRouter(AppRouter) // 루트 라우터 클래스 지정
  .setUrlType(UrlType.hash) // URL 해시(#) 기반 라우팅 사용
  .setSelector('#app'); // 애플리케이션이 마운트될 DOM 엘리먼트

const app = new SimpleBootFront(config);

// 4. 애플리케이션 실행
app.run();

console.log('Simple-Boot-Front application started.');

// 브라우저 환경에서 실행 시, #app 엘리먼트 내부에 라우팅된 컴포넌트가 표시됩니다.
// URL을 #/about으로 변경하면 AboutPage가 표시됩니다.

1.3. 의존성 주입(DI) 컨테이너 연동

SimpleBootFront는 SimpleApplication을 상속받으므로, Simple-Boot Core의 강력한 의존성 주입(DI) 컨테이너인 SimstanceManager를 그대로 활용합니다. 이는 프론트엔드 애플리케이션에서도 백엔드에서와 동일한 방식으로 객체들을 관리하고 의존성을 주입받을 수 있음을 의미합니다.

SimpleBootFront는 초기화 과정에서 SimstanceManager 인스턴스를 생성하고, 자신(SimpleBootFront 인스턴스)과 SimstanceManager 자신을 DI 컨테이너에 등록합니다.
@Sim 데코레이터로 등록된 모든 클래스는 SimpleBootFront 애플리케이션 내에서 DI 컨테이너의 관리를 받게 됩니다.
app.sim(MyService)와 같이 SimpleBootFront 인스턴스를 통해 DI 컨테이너로부터 객체를 조회할 수 있습니다.

이러한 DI 컨테이너 연동은 프론트엔드 애플리케이션의 모듈성을 높이고, 테스트 용이성을 향상시키며, 복잡한 객체 그래프를 효율적으로 관리할 수 있도록 돕습니다.

이 장에서는 SimpleBootFront의 기본적인 구조와 초기화, 그리고 SimFrontOption을 통한 설정 관리 및 DI 컨테이너 연동에 대해 알아보았습니다. 다음 장에서는 Simple-Boot-Front의 핵심인 컴포넌트 시스템과 dom-render와의 통합에 대해 더 깊이 탐구하겠습니다.

제2장: 컴포넌트 시스템 - UI 구성의 핵심

프론트엔드 프레임워크의 가장 중요한 역할 중 하나는 사용자 인터페이스(UI)를 재사용 가능하고 관리하기 쉬운 컴포넌트 단위로 구성하는 것입니다. Simple-Boot-Front는 @Component 데코레이터를 통해 컴포넌트를 정의하고, dom-render 라이브러리와의 통합을 통해 반응형 UI 렌더링을 구현합니다. 이 장에서는 컴포넌트 시스템의 설계와 동작 원리를 알아봅니다.

2.1. `@Component` 데코레이터와 컴포넌트 정의

@Component 데코레이터는 클래스를 UI 컴포넌트로 선언하는 역할을 합니다. 이 데코레이터는 컴포넌트의 템플릿(HTML), 스타일(CSS), 그리고 컴포넌트가 DOM에서 사용될 때의 태그 이름(selector)을 정의합니다.

// decorators/Component.ts
export interface ComponentConfig {
    selector?: string; // 컴포넌트의 HTML 태그 이름 (기본값: 클래스명 소문자)
    noStrip?: boolean; // 컴포넌트의 루트 엘리먼트를 유지할지 여부
    template?: string; // 컴포넌트의 HTML 템플릿
    styles?: (string)[]  | string; // 컴포넌트의 CSS 스타일
    proxy?: SimConfigProxy; // 컴포넌트 인스턴스에 적용될 프록시 핸들러
    using?: SimConfigUsing; // 컴포넌트의 의존성 (DI 컨테이너 힌트)
}

export const Component = (configOrTarget: ConstructorType<any> | ComponentConfig): void | GenericClassDecorator<ConstructorType<any>> => {
    if (typeof configOrTarget === 'function') {
        // @Component 데코레이터가 인자 없이 사용될 때 (예: @Component)
        componentProcess({}, configOrTarget);
    } else {
        // @Component 데코레이터가 인자와 함께 사용될 때 (예: @Component({ template: '...' }))
        return (target: ConstructorType<any>) => {
            componentProcess(configOrTarget, target);
        }
    }
};

const componentProcess = (config: ComponentConfig, target: ConstructorType<any>) => {
    if (!config.selector) {
        config.selector = target.name.toLowerCase(); // 셀렉터 기본값 설정
    }
    ReflectUtils.defineMetadata(ComponentMetadataKey, config, target); // 메타데이터 저장
    componentSelectors.set(config.selector.toLowerCase(), target); // 셀렉터와 클래스 매핑 저장
};

@Component 데코레이터는 클래스에 컴포넌트 관련 메타데이터를 추가하고, componentSelectors 맵에 컴포넌트의 셀렉터(태그 이름)와 해당 클래스를 매핑하여 저장합니다. 이 맵은 Simple-Boot-Front가 dom-render와 연동할 때 사용됩니다.

2.2. `dom-render`와의 통합

Simple-Boot-Front는 UI 렌더링 엔진으로 dom-render를 사용합니다. dom-render는 JavaScript Proxy 기반의 반응형 시스템과 HTML 템플릿을 직접 조작하는 기능을 제공합니다. SimpleBootFront는 @Component로 정의된 클래스들을 dom-render가 인식할 수 있는 형태로 변환하여 등록합니다.

`SimpleBootFront.initDomRenderTargetElements` 메소드

이 메소드는 componentSelectors 맵에 저장된 모든 컴포넌트들을 순회하며, dom-render의 DomRender.createComponent 메소드를 사용하여 dom-render의 TargetElement 객체로 변환합니다. 이렇게 변환된 TargetElement 객체들은 SimpleBootFront의 domRenderTargetElements 배열에 추가되며, 이 배열은 dom-render의 config.targetElements로 주입됩니다.

// SimpleBootFront.ts (개념적)
private initDomRenderTargetElements() {
  const selectors = componentSelectors; // @Component로 등록된 모든 컴포넌트 정보
  selectors.forEach((val, name) => {
    const componentConfig = getComponent(val); // 컴포넌트의 설정(template, styles 등) 가져오기
    const domRenderTargetElement = RawSet.createComponentTargetElement({
      name: name, // HTML 태그 이름 (예: 'my-component')
      noStrip: componentConfig.noStrip,
      objFactory: (element, obj, rawSet, constructorParam) => {
        // 이 팩토리는 dom-render가 컴포넌트를 렌더링할 때 호출됩니다.
        // Simple-Boot의 DI 컨테이너를 통해 컴포넌트 인스턴스를 생성하고 프록시를 적용합니다.
        const newSimInstance = this.simstanceManager.newSim({ target: val });
        // ... 컴포넌트 인스턴스에 추가 프록시 적용 (ComponentConfig.proxy) ...
        return newSimInstance;
      },
      template: componentConfig.template,
      styles: componentConfig.styles
    });
    this.domRenderTargetElements.push(domRenderTargetElement);
  });
}

이 과정을 통해 dom-render는 HTML 템플릿에서 <my-component>와 같은 커스텀 태그를 만나면, Simple-Boot-Front가 제공하는 objFactory를 호출하여 @Component 클래스의 인스턴스를 생성하고, 해당 인스턴스의 데이터와 생명주기를 관리하며 템플릿을 렌더링하게 됩니다.

예제: `@Component` 데코레이터와 `dom-render` 통합

템플릿과 스타일은 별도의 파일로 분리하여 관리하는 것이 좋습니다. 이렇게 하면 코드의 재사용성과 유지보수성이 향상됩니다. 웹팩(Webpack)과 같은 빌드 도구의 로더(예: raw-loader)를 사용하면 HTML과 CSS 파일을 직접 문자열로 가져와 컴포넌트의 template과 styles 속성에 주입할 수 있습니다.

dom-render 템플릿 문법에 따라 컴포넌트 인스턴스의 속성 및 메소드에 접근할 때는 @this@ 키워드를 사용합니다.

./my-greeting.component.html

<div>Hello, ${@this@.name}$!</div>
<button dr-event-click="@this@.changeName()">Change Name</button>

./my-greeting.component.css

my-greeting { 
  display: block; 
  padding: 10px; 
  border: 1px solid blue; 
  margin-bottom: 10px; 
}
my-greeting button { 
  background-color: lightblue; 
  border: none; 
  padding: 5px 10px; 
  cursor: pointer; 
}

이제 위 파일들을 컴포넌트에서 import하여 사용합니다.

import 'reflect-metadata';
import { SimpleBootFront } from '@dooboostore/simple-boot-front/SimpleBootFront';
import { SimFrontOption, UrlType } from '@dooboostore/simple-boot-front/option/SimFrontOption';
import { Sim } from '@dooboostore/simple-boot/decorators/SimDecorator';
import { Component } from '@dooboostore/simple-boot-front/decorators/Component';

// 위에서 정의한 외부 템플릿과 스타일 파일을 가져옵니다.
// (실제 사용을 위해서는 webpack 설정 등이 필요합니다)
import template from './my-greeting.component.html';
import styles from './my-greeting.component.css';

// 1. 간단한 컴포넌트 정의
@Sim // Simple-Boot DI 컨테이너에 등록
@Component({
  selector: 'my-greeting', // HTML에서 <my-greeting> 태그로 사용
  template, // './my-greeting.component.html' 파일의 내용
  styles,   // './my-greeting.component.css' 파일의 내용
})
class MyGreetingComponent {
  name: string = 'World';

  changeName() {
    this.name = this.name === 'World' ? 'Simple-Boot-Front' : 'World';
    console.log(`Name changed to: ${this.name}`);
  }
}

// 2. 애플리케이션의 루트 컴포넌트 (라우터 역할도 겸함)
@Sim
@Component({
  template: `
    <h1>Simple-Boot-Front App</h1>
    <my-greeting></my-greeting> <!-- 정의한 컴포넌트 사용 -->
    <my-greeting></my-greeting> <!-- 여러 번 사용 가능 -->
  `
})
class AppRootComponent {}

// 3. SimpleBootFront 인스턴스 생성 및 설정
const config = new SimFrontOption(window)
  .setRootRouter(AppRootComponent) // 루트 컴포넌트를 라우터로 설정 (여기서는 단순 컴포넌트 렌더링 목적)
  .setUrlType(UrlType.hash)
  .setSelector('#app');

const app = new SimpleBootFront(config);

// 4. 애플리케이션 실행
app.run();

console.log('Simple-Boot-Front component example started.');

/* 예상 출력 (브라우저 콘솔):
Name changed to: Simple-Boot-Front
Name changed to: World
...
(버튼 클릭 시마다 name 속성이 변경되고, dom-render에 의해 UI가 자동 업데이트됨)
*/

2.3. 컴포넌트 생명주기

Simple-Boot-Front의 컴포넌트는 Simple-Boot Core의 생명주기 콜백과 dom-render의 생명주기 훅을 모두 활용합니다. 이를 통해 컴포넌트의 생성, 초기화, 렌더링, 소멸 등 다양한 시점에 특정 로직을 실행할 수 있습니다.

Simple-Boot Core 생명주기:
- OnSimCreate: DI 컨테이너에 의해 인스턴스가 생성된 직후.
- @PostConstruct: 인스턴스 생성 후 특정 메소드 호출.
- OnSimCreateCompleted: 인스턴스 생성 및 모든 프록시/AOP 적용 완료 후.
dom-render 생명주기:
- OnCreateRender: 컴포넌트가 DOM에 렌더링되기 직전 (데이터 바인딩 전).
- OnInitRender: 컴포넌트의 초기 렌더링이 완료된 후.
- OnDestroyRender: 컴포넌트가 DOM에서 제거될 때.

이러한 생명주기 훅들을 조합하여 컴포넌트의 복잡한 초기화 및 정리 로직을 체계적으로 관리할 수 있습니다.

예제: 컴포넌트 생명주기 훅 사용

생명주기 예제 컴포넌트도 템플릿과 스타일을 외부 파일로 분리할 수 있습니다.

./my-lifecycle.component.html

<div>Lifecycle Test: ${@this@.message}$</div>

./my-lifecycle.component.css

my-lifecycle-component { 
  border: 1px dashed green; 
  padding: 10px; 
  margin-bottom: 10px; 
}

이제 이 파일들을 생명주기 컴포넌트 예제에서 사용합니다.

import 'reflect-metadata';
import { SimpleBootFront } from '@dooboostore/simple-boot-front/SimpleBootFront';
import { SimFrontOption, UrlType } from '@dooboostore/simple-boot-front/option/SimFrontOption';
import { Sim } from '@dooboostore/simple-boot/decorators/SimDecorator';
import { Component } from '@dooboostore/simple-boot-front/decorators/Component';
import { OnSimCreate, PostConstruct, OnSimCreateCompleted } from '@dooboostore/simple-boot/lifecycle/OnSimCreate'; // Simple-Boot Core 생명주기
import { OnCreateRender, OnInitRender, OnDestroyRender } from '@dooboostore/dom-render/lifecycle/OnCreateRender'; // dom-render 생명주기

// 외부 템플릿 및 스타일 파일 임포트
import template from './my-lifecycle.component.html';
import styles from './my-lifecycle.component.css';

@Sim
@Component({
  selector: 'my-lifecycle-component',
  template, // './my-lifecycle.component.html' 파일의 내용
  styles,   // './my-lifecycle.component.css' 파일의 내용
})
class MyLifecycleComponent implements 
  OnSimCreate, 
  PostConstruct, 
  OnSimCreateCompleted<MyLifecycleComponent>, 
  OnCreateRender, 
  OnInitRender, 
  OnDestroyRender 
{
  message: string = 'Initial';

  constructor() {
    console.log('1. Constructor: Component instance created.');
  }

  onSimCreate(): void {
    console.log('2. OnSimCreate: DI container finished creating instance.');
    this.message = 'OnSimCreate';
  }

  @PostConstruct()
  postConstructMethod() {
    console.log('3. @PostConstruct: Specific method called after construction.');
    this.message = 'PostConstruct';
  }

  onSimCreateProxyCompleted(proxyThis: MyLifecycleComponent): void {
    console.log('4. OnSimCreateCompleted: All proxies/AOP applied. Final instance ready.');
    this.message = 'OnSimCreateCompleted';
  }

  onCreateRender(): void {
    console.log('5. OnCreateRender: dom-render is about to render this component.');
    this.message = 'OnCreateRender';
  }

  onInitRender(): void {
    console.log('6. OnInitRender: Initial rendering by dom-render completed.');
    this.message = 'OnInitRender';
  }

  onDestroyRender(): void {
    console.log('7. OnDestroyRender: Component is being removed from DOM.');
    // 리소스 정리, 이벤트 리스너 해제 등
  }
}

@Sim
@Component({
  template: `
    <h1>Lifecycle App</h1>
    <button dr-event-click="@this@.toggleComponent()">Toggle Component</button>
    <my-lifecycle-component dr-if="@this@.showComponent"></my-lifecycle-component>
  `
})
class AppRootComponent {
  showComponent: boolean = true;

  toggleComponent() {
    this.showComponent = !this.showComponent;
    console.log('\n--- Toggling component visibility to:', this.showComponent, '---');
  }
}

const config = new SimFrontOption(window)
  .setRootRouter(AppRootComponent)
  .setUrlType(UrlType.hash)
  .setSelector('#app');

const app = new SimpleBootFront(config);
app.run();

console.log('Simple-Boot-Front lifecycle example started.');

/* 예상 출력 (콘솔):
1. Constructor: Component instance created.
2. OnSimCreate: DI container finished creating instance.
3. @PostConstruct: Specific method called after construction.
4. OnSimCreateCompleted: All proxies/AOP applied. Final instance ready.
5. OnCreateRender: dom-render is about to render this component.
6. OnInitRender: Initial rendering by dom-render completed.

--- Toggling component visibility to: false ---
7. OnDestroyRender: Component is being removed from DOM.

--- Toggling component visibility to: true ---
1. Constructor: Component instance created.
2. OnSimCreate: DI container finished creating instance.
3. @PostConstruct: Specific method called after construction.
4. OnSimCreateCompleted: All proxies/AOP applied. Final instance ready.
5. OnCreateRender: dom-render is about to render this component.
6. OnInitRender: Initial rendering by dom-render completed.
*/
*/

이 장에서는 `Simple-Boot-Front`의 컴포넌트 시스템과 `dom-render`와의 통합, 그리고 다양한 생명주기 훅들을 살펴보았습니다. 다음 장에서는 SPA의 핵심인 라우팅과 내비게이션 시스템에 대해 알아보겠습니다.

제3장: 라우팅과 내비게이션 - SPA의 흐름 제어

단일 페이지 애플리케이션(SPA)에서 라우팅은 여러 페이지를 가진 것처럼 보이게 하는 핵심 메커니즘입니다. Simple-Boot-Front는 simple-boot-core의 라우팅 시스템과 dom-render의 UI 렌더링 기능을 결합하여 강력하고 유연한 클라이언트 측 라우팅을 제공합니다. 이 장에서는 라우팅 시스템의 설계와 내비게이션, 그리고 라우팅 가드에 대해 알아봅니다.

3.1. `@Router`와 `@Route`를 활용한 라우팅

Simple-Boot-Front의 라우팅은 simple-boot-core의 @Router와 @Route 데코레이터를 기반으로 합니다. 이 데코레이터들을 사용하여 URL 경로와 컴포넌트(또는 메소드)를 선언적으로 매핑합니다.

@Router: 클래스에 적용되어 해당 클래스가 라우터임을 선언하고, 기본 경로(path)와 하위 라우팅 규칙(route, routers)을 정의합니다. SimpleBootFront의 rootRouter 옵션에 지정된 클래스가 최상위 라우터가 됩니다.
@Route: @Router 클래스 내의 메소드에 적용되어 특정 경로(path)에 해당 메소드를 매핑합니다. 이 메소드는 RouterModule 객체를 인자로 받아 현재 라우팅에 대한 상세 정보(경로 데이터, 쿼리 파라미터 등)에 접근할 수 있습니다.

구현 원리

SimpleBootFront는 simple-boot-core의 RouterManager를 사용하여 라우팅을 처리합니다. RouterManager는 애플리케이션 초기화 시 모든 @Router 및 @Route 메타데이터를 수집하여 라우팅 맵을 구축합니다.

사용자가 router-link를 클릭하거나 app.goRouting()을 호출하여 URL이 변경되면, SimpleBootFront는 dom-render의 라우터(PathRouter 또는 HashRouter)를 통해 URL 변경을 감지합니다. 이후 RouterManager의 routing() 메소드를 호출하여 변경된 URL에 매칭되는 @Route를 찾고, 해당 @Route에 연결된 컴포넌트를 dom-render를 통해 #app 엘리먼트 내부에 렌더링합니다.

특히, SimpleBootFront의 루트 라우터 컴포넌트 템플릿 내에 <router dr-this="this.child" dr-this:type="outlet"></router>와 같은 플레이스홀더를 두어, 라우팅된 컴포넌트가 이 위치에 동적으로 삽입되도록 합니다. RouterAction 인터페이스를 구현한 라우터 클래스는 canActivate 메소드를 통해 this.child 속성에 다음 라우팅될 컴포넌트 인스턴스를 할당할 수 있습니다.

예제: `@Router`와 `@Route`를 활용한 라우팅

이 예제에서는 quick-start에서 사용된 라우팅 방식을 적용합니다. 이 방식은 @Router 데코레이터의 route 속성에 경로와 컴포넌트를 직접 매핑하여 라우팅 규칙을 한곳에서 관리합니다.

먼저, 라우팅에 사용될 각 페이지 컴포넌트의 템플릿을 별도의 HTML 파일로 정의합니다.

./home-page.component.html

<div><h1>Home Page</h1><p>Welcome to the home page!</p></div>

./about-page.component.html

<div><h1>About Page</h1><p>Learn more about us.</p></div>

./user-detail-page.component.html

<div>
  <h1>User Detail Page</h1>
  <p>User ID: ${@this@.userId}$</p>
  <p>Query Param (name): ${@this@.userName}$</p>
</div>

다음으로, 메인 라우터 컴포넌트의 템플릿과 스타일을 정의합니다.

./app-router.component.html

<nav>
  <button dr-event-click="$router?.go({path: '/'})">Home</button>
  <button dr-event-click="$router?.go({path: '/about'})">About</button>
  <button dr-event-click="$router?.go({path: '/users/123?name=Alice'})">User 123 (Alice)</button>
  <button dr-event-click="$router?.go({path: '/users/456?name=Bob'})">User 456 (Bob)</button>
</nav>
<main>
  <div dr-this="@this@.child"></div> <!-- 라우팅된 컴포넌트가 렌더링될 위치 -->
</main>

./app-router.component.css

nav button { 
  margin-right: 10px; 
  padding: 5px 10px; 
  cursor: pointer; 
}
main { 
  border: 1px solid #ccc; 
  padding: 20px; 
  margin-top: 20px; 
  min-height: 150px; 
}

이제 이 파일들을 사용하여 새로운 라우팅 방식이 적용된 전체 코드를 작성합니다.

import 'reflect-metadata';
import { SimpleBootFront } from '@dooboostore/simple-boot-front/SimpleBootFront';
import { SimFrontOption, UrlType } from '@dooboostore/simple-boot-front/option/SimFrontOption';
import { Sim } from '@dooboostore/simple-boot/decorators/SimDecorator';
import { Component } from '@dooboostore/simple-boot-front/decorators/Component';
import { Router } from '@dooboostore/simple-boot/decorators/route/Router';
import { RouterAction } from '@dooboostore/simple-boot/route/RouterAction';
import { RouterModule } from '@dooboostore/simple-boot/route/RouterModule';
import { ComponentSet } from '@dooboostore/simple-boot-front/component/ComponentSet';

// HTML 템플릿 및 CSS 파일들을 임포트합니다.
import homeTemplate from './home-page.component.html';
import aboutTemplate from './about-page.component.html';
import userDetailTemplate from './user-detail-page.component.html';
import appRouterTemplate from './app-router.component.html';
import appRouterStyles from './app-router.component.css';

// 1. 페이지 컴포넌트 정의
@Sim
@Component({ template: homeTemplate })
class HomePage {}

@Sim
@Component({ template: aboutTemplate })
class AboutPage {}

@Sim
@Component({ template: userDetailTemplate })
class UserDetailPage {
  userId: string = '';
  userName: string = '';

  onActivate(routerModule: RouterModule) {
    this.userId = routerModule.pathData?.id || 'N/A';
    this.userName = routerModule.queryParams?.name || 'N/A';
    console.log(`UserDetailPage activated for ID: ${this.userId}, Name: ${this.userName}`);
  }
}

// 2. 애플리케이션의 루트 라우터 컴포넌트
@Sim
@Router({
    path: '', // 루트 경로
    route: {
        '/': HomePage,
        '/about': AboutPage,
        '/users/{id}': UserDetailPage // @Route 데코레이터 대신 route 객체에 직접 매핑
    }
})
@Component({
  template: appRouterTemplate,
  styles: appRouterStyles
})
export class AppRouter implements RouterAction {
  child?: ComponentSet<any>; // 라우팅된 컴포넌트를 ComponentSet으로 관리

  async canActivate(url: any, module: any) {
    // 라우팅된 모듈을 ComponentSet으로 감싸서 child 속성에 할당
    this.child = new ComponentSet(module);
    console.log(`[AppRouter] Navigating to: ${url.intent.pathname}, Module: ${module?.constructor.name}`);
    if (typeof module?.onActivate === 'function') {
      module.onActivate(url.routerModule);
    }
  }
}

// 3. SimpleBootFront 인스턴스 생성 및 설정
const config = new SimFrontOption(window)
  .setRootRouter(AppRouter)
  .setUrlType(UrlType.hash) // URL 해시(#) 기반 라우팅 사용
  .setSelector('#app');

const app = new SimpleBootFront(config);

// 4. 애플리케이션 실행
app.run();

console.log('Simple-Boot-Front routing example started.');

// 브라우저에서 버튼을 클릭하거나 URL 해시를 변경하여 라우팅 테스트

3.2. `$router.go()`를 이용한 프로그래밍 방식 내비게이션

Simple-Boot-Front는 dom-render에서 제공하는 내장 $router 객체를 통해 프로그래밍 방식으로 내비게이션을 처리합니다. 템플릿 내의 이벤트 핸들러에서 $router.go() 메소드를 호출하여 원하는 경로로 이동할 수 있습니다.

$router.go({path: '/...'}): dr-event-click과 같은 이벤트 속성 내에서 호출되어, 인자로 전달된 path로 클라이언트 측 라우팅을 수행합니다. 쿼리 파라미터도 경로에 포함할 수 있습니다.

구현 원리

dom-render는 템플릿을 파싱할 때 $router라는 특수 변수를 주입합니다. 이 객체는 dom-render의 라우터 인스턴스(PathRouter 또는 HashRouter)와 연결되어 있습니다. dr-event-click 등에서 $router.go()가 호출되면, dom-render는 내부적으로 URL을 변경하고 라우팅을 트리거합니다. 이 변경은 SimpleBootFront가 감지하여 RouterManager를 통해 적절한 컴포넌트를 렌더링하게 합니다.

3.3. `RouterAction`을 통한 라우팅 가드

RouterAction 인터페이스는 라우팅 과정에 개입하여 특정 로직을 실행할 수 있는 라우팅 가드(Routing Guard) 기능을 제공합니다. 이는 인증, 권한 확인, 데이터 로딩 등 라우팅이 완료되기 전에 수행되어야 할 작업에 유용합니다.

canActivate(url: RoutingDataSet, module: any): @Router 클래스가 RouterAction 인터페이스를 구현하면, canActivate 메소드가 라우팅되기 전에 호출됩니다. url 객체는 현재 Intent와 RouterModule 정보를 포함하며, module은 다음 라우팅될 컴포넌트 인스턴스입니다. 이 메소드 내에서 비동기 작업을 수행하거나, 특정 조건에 따라 라우팅을 중단할 수 있습니다.

구현 원리

Simple-Boot Core의 RouterManager는 라우팅 체인(routerChains)을 순회하며 RouterAction 인터페이스를 구현한 라우터 인스턴스를 발견하면 canActivate 메소드를 호출합니다. SimpleBootFront의 AppRouter 예제에서 canActivate를 구현하여 this.child 속성에 다음 라우팅될 컴포넌트를 할당하는 것이 대표적인 사용 예입니다.

이러한 라우팅 시스템은 SPA의 복잡한 내비게이션 요구사항을 충족시키고, 애플리케이션의 흐름을 체계적으로 제어할 수 있도록 돕습니다.

다음 장에서는 Simple-Boot-Front의 기능을 확장하는 동적 스크립트와 내장 서비스들에 대해 알아보겠습니다.

제4장: 동적 스크립트와 서비스 - 프레임워크 확장

프레임워크는 핵심 기능 외에도 애플리케이션 개발을 돕는 다양한 유틸리티와 확장 메커니즘을 제공해야 합니다. Simple-Boot-Front는 동적 스크립트와 내장 서비스, 그리고 커스텀 서비스 개발을 통해 프레임워크의 기능을 확장하고 재사용 가능한 로직을 관리하는 방법을 제공합니다. 이 장에서는 이러한 확장 메커니즘의 설계와 사용법을 알아봅니다.

4.1. `@Script` 데코레이터와 동적 스크립트

@Script 데코레이터는 특정 클래스를 템플릿 내에서 직접 호출할 수 있는 동적 스크립트로 등록하는 역할을 합니다. 이는 템플릿에서 복잡한 로직을 직접 작성하는 대신, 미리 정의된 JavaScript 함수를 호출하여 데이터를 처리하거나 포맷팅하는 데 유용합니다.

@Script: 클래스에 적용되며, name 속성을 통해 템플릿에서 호출될 스크립트의 이름을 지정합니다. 이 클래스는 ScriptRunnable 인터페이스를 구현해야 합니다.
ScriptRunnable: run(...arg: any): any 메소드를 정의하는 인터페이스입니다. 템플릿에서 스크립트가 호출될 때 이 run 메소드가 실행됩니다.

구현 원리

SimpleBootFront는 초기화 과정에서 @Script로 등록된 모든 클래스들을 수집하여 dom-render의 config.scripts 객체에 등록합니다. 템플릿 내에서 ${$scripts.scriptName(...)}$ 형태로 호출되면, dom-render는 config.scripts에 등록된 해당 함수를 찾아 실행합니다. 이때 ScriptRunnable 인스턴스의 run 메소드가 호출됩니다.

// decorators/Script.ts (개념적)
export const scripts = new Map<string, ConstructorType<ScriptRunnable>>();

export const Script = (config?: ScriptConfig): GenericClassDecorator<ConstructorType<ScriptRunnable>> => {
    return (target: ConstructorType<any>) => {
        // config.name이 없으면 클래스 이름을 기본값으로 사용
        if (!config || !config.name) {
            config = { ...config, name: target.name };
        }
        scripts.set(config.name, target); // 스크립트 이름과 클래스 매핑 저장
        ReflectUtils.defineMetadata(ScriptMetadataKey, config, target);
        return target;
    }
}

// SimpleBootFront.ts (개념적)
private initDomRenderScripts() {
  const simstanceManager = this.simstanceManager;
  scripts.forEach((scriptClass, name) => {
    this.domRenderConfig.scripts![name] = function (...args: any) {
      // 템플릿에서 스크립트 호출 시, DI 컨테이너를 통해 ScriptRunnable 인스턴스 생성/조회
      const scriptRunnableInstance = simstanceManager.getOrNewSim({ target: scriptClass });
      // ScriptRunnable의 run 메소드 호출
      return scriptRunnableInstance.run(...args);
    }
  });
}

예제: `@Script` 데코레이터와 동적 스크립트 사용

먼저, 컴포넌트의 템플릿을 별도 파일로 정의합니다.

./dynamic-script-example.component.html

<h1>Dynamic Scripts Example</h1>
<p>Current Date: ${$scripts.dateFormat(@this@.currentDate, 'YYYY/MM/DD HH:mm:ss')}$</p>
<p>Short Text: ${$scripts.truncateText(@this@.longText, 20)}$</p>
<p>Original Text: ${@this@.longText}$</p>

이제 스크립트와 컴포넌트의 전체 코드를 작성합니다.

import 'reflect-metadata';
import { SimpleBootFront } from '@dooboostore/simple-boot-front/SimpleBootFront';
import { SimFrontOption, UrlType } from '@dooboostore/simple-boot-front/option/SimFrontOption';
import { Sim } from '@dooboostore/simple-boot/decorators/SimDecorator';
import { Component } from '@dooboostore/simple-boot-front/decorators/Component';
import { Script } from '@dooboostore/simple-boot-front/decorators/Script';
import { ScriptRunnable } from '@dooboostore/simple-boot-front/script/ScriptRunnable';

// 템플릿 파일 임포트
import template from './dynamic-script-example.component.html';

// 1. 날짜 포맷팅 스크립트 정의
@Sim
@Script({ name: 'dateFormat' }) // 템플릿에서 $scripts.dateFormat로 호출
class DateFormatScript implements ScriptRunnable {
  run(date: Date, format: string = 'YYYY-MM-DD'): string {
    const year = date.getFullYear();
    const month = String(date.getMonth() + 1).padStart(2, '0');
    const day = String(date.getDate()).padStart(2, '0');
    const hours = String(date.getHours()).padStart(2, '0');
    const minutes = String(date.getMinutes()).padStart(2, '0');
    const seconds = String(date.getSeconds()).padStart(2, '0');

    let formatted = format;
    formatted = formatted.replace('YYYY', String(year));
    formatted = formatted.replace('MM', month);
    formatted = formatted.replace('DD', day);
    formatted = formatted.replace('HH', hours);
    formatted = formatted.replace('mm', minutes);
    formatted = formatted.replace('ss', seconds);
    return formatted;
  }
}

// 2. 텍스트 자르기 스크립트 정의
@Sim
@Script({ name: 'truncateText' })
class TruncateTextScript implements ScriptRunnable {
  run(text: string, maxLength: number): string {
    if (text.length <= maxLength) {
      return text;
    }
    return text.substring(0, maxLength) + '...';
  }
}

// 3. 애플리케이션 루트 컴포넌트
@Sim
@Component({ template })
class AppRootComponent {
  currentDate: Date = new Date();
  longText: string = 'This is a very long text that needs to be truncated for display purposes.';
}

// 4. SimpleBootFront 인스턴스 생성 및 실행
const config = new SimFrontOption(window)
  .setRootRouter(AppRootComponent)
  .setUrlType(UrlType.hash)
  .setSelector('#app');

const app = new SimpleBootFront(config);
app.run();

console.log('Dynamic scripts example started.');

4.2. 내장 서비스 활용 (Cookie, Storage, MetaTag)

Simple-Boot-Front는 프론트엔드 개발에서 자주 사용되는 기능들을 서비스 형태로 내장하여 제공합니다. 이 서비스들은 DI 컨테이너에 @Sim으로 등록되어 있으므로, 필요한 곳에서 주입받아 사용할 수 있습니다.

CookieService: 브라우저 쿠키를 읽고, 쓰고, 삭제하는 기능을 제공합니다.
StorageService: localStorage와 sessionStorage를 쉽게 사용할 수 있도록 래핑합니다.
MetaTagService: 동적으로 HTML <meta> 태그를 조작하여 SEO나 SNS 공유(OG Tag)에 필요한 정보를 설정합니다.

예제: 내장 서비스 활용

컴포넌트의 템플릿과 스타일을 별도 파일로 분리합니다.

./builtin-services-example.component.html

<h1>Built-in Services Example</h1>
<section>
  <h2>Cookie Service</h2>
  <input type="text" dr-value-link="@this@.cookieValue" placeholder="Enter cookie value">
  <button dr-event-click="@this@.setCookie()">Set Cookie</button>
  <button dr-event-click="@this@.getCookie()">Get Cookie</button>
  <button dr-event-click="@this@.deleteCookie()">Delete Cookie</button>
  <p>Current Cookie: ${@this@.displayCookieValue}$</p>
</section>

<section>
  <h2>Storage Service (LocalStorage)</h2>
  <input type="text" dr-value-link="@this@.storageValue" placeholder="Enter storage value">
  <button dr-event-click="@this@.setStorage()">Set Storage</button>
  <button dr-event-click="@this@.getStorage()">Get Storage</button>
  <button dr-event-click="@this@.removeStorage()">Remove Storage</button>
  <p>Current Storage: ${@this@.displayStorageValue}$</p>
</section>

<section>
  <h2>Meta Tag Service</h2>
  <button dr-event-click="@this@.setMetaTags()">Set OG Meta Tags</button>
  <p>Check browser's head section for meta tags after clicking.</p>
</section>

./builtin-services-example.component.css

section { 
  border: 1px solid #eee; 
  padding: 15px; 
  margin-bottom: 20px; 
}
input { 
  margin-right: 10px; 
  padding: 5px; 
}
button { 
  padding: 5px 10px; 
  margin-right: 5px; 
  cursor: pointer; 
}

이제 이 파일들을 사용하여 전체 예제 코드를 작성합니다.

import 'reflect-metadata';
import { SimpleBootFront } from '@dooboostore/simple-boot-front/SimpleBootFront';
import { SimFrontOption, UrlType } from '@dooboostore/simple-boot-front/option/SimFrontOption';
import { Sim } from '@dooboostore/simple-boot/decorators/SimDecorator';
import { Component } from '@dooboostore/simple-boot-front/decorators/Component';
import { CookieService } from '@dooboostore/simple-boot-front/service/CookieService';
import { StorageService } from '@dooboostore/simple-boot-front/service/StorageService';
import { MetaTagService } from '@dooboostore/simple-boot-front/service/MetaTagService';

// 템플릿 및 스타일 파일 임포트
import template from './builtin-services-example.component.html';
import styles from './builtin-services-example.component.css';

@Sim
@Component({ template, styles })
class AppRootComponent {
  cookieValue: string = '';
  displayCookieValue: string = '';
  storageValue: string = '';
  displayStorageValue: string = '';

  constructor(
    private cookieService: CookieService,
    private storageService: StorageService,
    private metaTagService: MetaTagService
  ) {}

  setCookie() {
    this.cookieService.set('myAppCookie', this.cookieValue, 3600 * 1000); // 1시간 유효
    this.displayCookieValue = this.cookieService.get('myAppCookie') || '';
    console.log('Cookie set:', this.displayCookieValue);
  }

  getCookie() {
    this.displayCookieValue = this.cookieService.get('myAppCookie') || '';
    console.log('Cookie get:', this.displayCookieValue);
  }

  deleteCookie() {
    this.cookieService.delete('myAppCookie');
    this.displayCookieValue = this.cookieService.get('myAppCookie') || '';
    console.log('Cookie deleted.');
  }

  setStorage() {
    this.storageService.setLocalStorageItem('myAppStorage', this.storageValue);
    this.displayStorageValue = this.storageService.getLocalStorageItem('myAppStorage') || '';
    console.log('Storage set:', this.displayStorageValue);
  }

  getStorage() {
    this.displayStorageValue = this.storageService.getLocalStorageItem('myAppStorage') || '';
    console.log('Storage get:', this.displayStorageValue);
  }

  removeStorage() {
    this.storageService.removeLocalStorageItem('myAppStorage');
    this.displayStorageValue = this.storageService.getLocalStorageItem('myAppStorage') || '';
    console.log('Storage removed.');
  }

  setMetaTags() {
    this.metaTagService.setMetaTag('meta[property="og:title"]', { content: 'My Awesome App' });
    this.metaTagService.setMetaTag('meta[property="og:description"]', { content: 'This is a description for my awesome app.' });
    this.metaTagService.setMetaTag('meta[property="og:image"]', { content: 'https://example.com/image.jpg' });
    console.log('Meta tags set. Check browser console and head section.');
  }
}

const config = new SimFrontOption(window)
  .setRootRouter(AppRootComponent)
  .setUrlType(UrlType.hash)
  .setSelector('#app');

const app = new SimpleBootFront(config);
app.run();

console.log('Built-in services example started.');

4.3. 커스텀 서비스 개발

Simple-Boot-Front는 Simple-Boot Core의 DI 컨테이너를 사용하므로, 커스텀 서비스를 개발하는 것은 매우 간단합니다. @Sim 데코레이터를 사용하여 일반 TypeScript 클래스를 DI 컨테이너에 등록하기만 하면 됩니다. 이렇게 등록된 서비스는 다른 @Sim 클래스나 @Component 클래스에서 의존성 주입을 통해 사용할 수 있습니다.

예제: 커스텀 서비스 개발

먼저, 커스텀 서비스를 사용하는 컴포넌트의 템플릿과 스타일을 별도 파일로 정의합니다.

./custom-service-example.component.html

<h1>Custom Service Example</h1>
<p>Result of 5 + 3: ${@this@.sumResult}$</p>
<p>Result of 10 - 4: ${@this@.diffResult}$</p>
<button dr-event-click="@this@.performCalculations()">Perform Calculations</button>

./custom-service-example.component.css

button { 
  padding: 8px 15px; 
  cursor: pointer; 
}

이제 이 파일들을 사용하여 전체 예제 코드를 작성합니다.

import 'reflect-metadata';
import { SimpleBootFront } from '@dooboostore/simple-boot-front/SimpleBootFront';
import { SimFrontOption, UrlType } from '@dooboostore/simple-boot-front/option/SimFrontOption';
import { Sim } from '@dooboostore/simple-boot/decorators/SimDecorator';
import { Component } from '@dooboostore/simple-boot-front/decorators/Component';

// 템플릿 및 스타일 파일 임포트
import template from './custom-service-example.component.html';
import styles from './custom-service-example.component.css';

// 1. 커스텀 서비스 정의
@Sim // DI 컨테이너에 등록
class MathService {
  add(a: number, b: number): number {
    console.log(`[MathService] Adding ${a} and ${b}`);
    return a + b;
  }

  subtract(a: number, b: number): number {
    console.log(`[MathService] Subtracting ${b} from ${a}`);
    return a - b;
  }
}

// 2. 커스텀 서비스를 사용하는 컴포넌트
@Sim
@Component({ template, styles })
class AppRootComponent {
  sumResult: number = 0;
  diffResult: number = 0;

  // 생성자 주입을 통해 MathService 인스턴스를 받음
  constructor(private mathService: MathService) {}

  performCalculations() {
    this.sumResult = this.mathService.add(5, 3);
    this.diffResult = this.mathService.subtract(10, 4);
    console.log('Calculations performed.');
  }
}

// 3. SimpleBootFront 인스턴스 생성 및 실행
const config = new SimFrontOption(window)
  .setRootRouter(AppRootComponent)
  .setUrlType(UrlType.hash)
  .setSelector('#app');

const app = new SimpleBootFront(config);
app.run();

console.log('Custom service example started.');

동적 스크립트와 서비스는 Simple-Boot-Front 애플리케이션의 기능을 확장하고, 코드의 재사용성을 높이며, 모듈 간의 깔끔한 의존성 관리를 가능하게 합니다. 이를 통해 복잡한 프론트엔드 로직을 체계적으로 구성할 수 있습니다.

다음 장에서는 Simple-Boot-Front가 Simple-Boot Core의 강력한 기능들을 어떻게 활용하여 프론트엔드 환경에 최적화된 통합을 이루는지 알아보겠습니다.

제5장: 프레임워크의 기반 - Simple-Boot Core 연동

Simple-Boot-Front는 Simple-Boot Core의 강력한 기능들을 프론트엔드 환경에서 활용할 수 있도록 긴밀하게 연동되어 있습니다. 이 장에서는 Simple-Boot-Front가 Simple-Boot Core의 의존성 주입(DI), 관점 지향 프로그래밍(AOP), 예외 처리 시스템을 어떻게 통합하고 활용하는지 알아봅니다.

5.1. Simple-Boot Core의 DI, AOP, 예외 처리 활용

Simple-Boot-Front는 SimpleApplication (Simple-Boot Core의 메인 클래스)을 상속받습니다. 이는 Simple-Boot-Front 인스턴스가 곧 SimpleApplication 인스턴스이기도 하다는 것을 의미합니다. 따라서 Simple-Boot Core에서 제공하는 모든 핵심 기능들을 프론트엔드 환경에서 그대로 사용할 수 있습니다.

의존성 주입 (DI):
- @Sim 데코레이터로 정의된 모든 클래스(서비스, 컴포넌트 등)는 Simple-Boot-Front의 DI 컨테이너(SimstanceManager)에 의해 관리됩니다.
- 생성자 주입을 통해 필요한 의존성을 자동으로 주입받을 수 있습니다.
- app.sim(MyService)와 같이 SimpleBootFront 인스턴스를 통해 DI 컨테이너로부터 객체를 조회할 수 있습니다.
관점 지향 프로그래밍 (AOP):
- @Before, @After, @Around 데코레이터를 사용하여 메소드 호출 전후에 공통 로직을 삽입할 수 있습니다.
- 이는 로깅, 성능 측정, 권한 확인 등 횡단 관심사를 비즈니스 로직과 분리하는 데 매우 효과적입니다.
예외 처리 시스템:
- @ExceptionHandler 데코레이터를 사용하여 메소드나 클래스 레벨에서 발생하는 예외를 선언적으로 처리할 수 있습니다.
- 전역 advice를 등록하여 애플리케이션 전반의 예외를 일관되게 관리할 수 있습니다.

예제: Simple-Boot Core 기능 활용

먼저, 예제 컴포넌트의 템플릿과 스타일을 별도 파일로 정의합니다.

./core-features-example.component.html

<h1>Simple-Boot Core Features</h1>
<button dr-event-click="@this@.fetchUser(1)">Fetch User 1</button>
<button dr-event-click="@this@.fetchUser(3)">Fetch User 3 (Not Found)</button>
<button dr-event-click="@this@.fetchUser(-1)">Fetch User -1 (Around Test)</button>
<button dr-event-click="@this@.createUser('JohnDoe', 25)">Create Valid User</button>
<button dr-event-click="@this@.createUser('123Invalid', -5)">Create Invalid User</button>

./core-features-example.component.css

button { 
  padding: 8px 15px; 
  margin: 5px; 
  cursor: pointer; 
}

이제 이 파일들을 사용하여 전체 예제 코드를 작성합니다.

import 'reflect-metadata';
import { SimpleBootFront } from '@dooboostore/simple-boot-front/SimpleBootFront';
import { SimFrontOption, UrlType } from '@dooboostore/simple-boot-front/option/SimFrontOption';
import { Sim } from '@dooboostore/simple-boot/decorators/SimDecorator';
import { Component } from '@dooboostore/simple-boot-front/decorators/Component';
import { Before, After, Around, AroundForceReturn } from '@dooboostore/simple-boot/decorators/aop/AOPDecorator';
import { ExceptionHandler } from '@dooboostore/simple-boot/decorators/exception/ExceptionDecorator';
import { ValidException, NotEmpty, Validation, Regexp, execValidationInValid } from '@dooboostore/simple-boot/decorators/validate/Validation';

// 템플릿 및 스타일 파일 임포트
import template from './core-features-example.component.html';
import styles from './core-features-example.component.css';

// 1. DI, AOP, 예외 처리 기능을 포함하는 서비스
@Sim
class UserService {
  private users: { id: number; name: string }[] = [];

  constructor() {
    this.users.push({ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' });
  }

  // AOP: 메소드 실행 전후 로깅
  @Before({ property: 'getUser' })
  logBeforeGetUser() {
    console.log('[AOP] Before getUser method.');
  }

  @After({ property: 'getUser' })
  logAfterGetUser() {
    console.log('[AOP] After getUser method.');
  }

  // AOP: Around를 사용하여 인자 수정 및 반환 값 검증
  @Around({
    before: (obj, prop, args) => {
      console.log(`[AOP] Around before ${String(prop)} with args:`, args);
      // 인자가 0보다 작으면 0으로 변경
      return args.map(arg => (typeof arg === 'number' && arg < 0) ? 0 : arg);
    },
    after: (obj, prop, args, result) => {
      console.log(`[AOP] Around after ${String(prop)} with result:`, result);
      if (!result) {
        throw new AroundForceReturn('User not found!'); // 강제 반환
      }
      return result;
    }
  })
  getUser(id: number) {
    console.log(`[UserService] Fetching user with ID: ${id}`);
    const user = this.users.find(u => u.id === id);
    if (!user) {
      throw new Error(`User with ID ${id} not found.`);
    }
    return user;
  }

  // 예외 처리: 특정 에러 타입 처리
  @ExceptionHandler({ type: Error })
  handleUserNotFoundError(error: Error) {
    console.error(`[UserService] Caught error: ${error.message}`);
    return null; // 에러 처리 후 null 반환
  }

  // 유효성 검증을 위한 사용자 모델
  @Validation(NotEmpty)
  @Validation(Regexp(/^[a-zA-Z]+$/))
  userName: string = '';

  @Validation((value: number) => value > 0)
  userAge: number = 0;

  // 사용자 생성 메소드 (유효성 검증 포함)
  createUser(name: string, age: number) {
    this.userName = name;
    this.userAge = age;

    try {
      const errors = execValidationInValid(this);
      if (errors.length > 0) {
        throw new ValidException(errors);
      }
      const newId = this.users.length + 1;
      this.users.push({ id: newId, name: name });
      console.log(`[UserService] User created: ${name} (ID: ${newId})`);
      return { id: newId, name: name };
    } catch (e: any) {
      if (e instanceof ValidException) {
        console.error('[UserService] Validation failed:', JSON.stringify(e.result));
      } else {
        console.error('[UserService] An unexpected error occurred:', e.message);
      }
      return null;
    }
  }
}

// 2. 애플리케이션 루트 컴포넌트
@Sim
@Component({ template, styles })
class AppRootComponent {
  constructor(private userService: UserService) {}

  fetchUser(id: number) {
    const user = this.userService.getUser(id);
    console.log(`Fetched User Result:`, user);
  }

  createUser(name: string, age: number) {
    this.userService.createUser(name, age);
  }
}

// 3. SimpleBootFront 인스턴스 생성 및 실행
const config = new SimFrontOption(window)
  .setRootRouter(AppRootComponent)
  .setUrlType(UrlType.hash)
  .setSelector('#app');

const app = new SimpleBootFront(config);
app.run();

console.log('Simple-Boot-Front Core features example started.');

5.2. 프론트엔드 환경에 최적화된 통합

Simple-Boot-Front는 Simple-Boot Core의 기능을 활용하면서도, 프론트엔드 환경의 특성을 고려하여 최적화된 통합을 제공합니다.

dom-render와의 연동: Simple-Boot-Front는 dom-render를 UI 렌더링 엔진으로 사용합니다. @Component로 정의된 클래스 인스턴스는 Simple-Boot Core의 DI 컨테이너에 의해 생성되고 관리되지만, 실제 DOM 렌더링은 dom-render가 담당합니다. SimpleBootFront는 이 두 프레임워크 간의 브릿지 역할을 하여, @Component 클래스가 dom-render의 컴포넌트로 인식되도록 합니다.
브라우저 API 접근: SimFrontOption을 통해 window 객체를 주입받아, CookieService, StorageService 등 브라우저의 전역 객체나 API를 활용하는 서비스들을 DI 컨테이너에 등록하고 관리합니다.
클라이언트 측 라우팅: Simple-Boot Core의 라우팅 시스템을 기반으로, PathRouter 또는 HashRouter를 사용하여 브라우저의 URL 변경을 감지하고 SPA 내비게이션을 처리합니다.

이러한 통합을 통해 개발자는 백엔드에서 사용하던 익숙한 DI, AOP, 예외 처리 패턴을 프론트엔드에서도 그대로 적용할 수 있으며, dom-render의 반응형 UI 기능과 결합하여 일관되고 효율적인 애플리케이션 개발 경험을 얻을 수 있습니다.

이 장에서는 Simple-Boot-Front가 Simple-Boot Core의 강력한 기능들을 어떻게 활용하여 프론트엔드 환경에 최적화된 통합을 이루는지 알아보았습니다. 이로써 우리는 Simple-Boot-Front의 모든 주요 기능과 그 기반이 되는 설계 원리를 탐구했습니다.

다음 부록에서는 Simple-Boot-Front 아키텍처의 장단점을 객관적으로 평가하고, 프레임워크를 확장하거나 기여하는 방안, 그리고 프론트엔드 프레임워크 개발자로서의 성장 로드맵에 대한 아이디어를 공유하겠습니다.

부록: 더 나아가기

이 책을 통해 우리는 Simple-Boot-Front 프레임워크의 설계와 구현 과정을 심층적으로 탐구했습니다. 프론트엔드 애플리케이션 개발에 필요한 핵심 기능들을 어떻게 구축하고, Simple-Boot Core 및 dom-render와 어떻게 통합되는지 살펴보았습니다. 이 부록에서는 Simple-Boot-Front 아키텍처의 장단점을 객관적으로 평가하고, 프레임워크를 확장하거나 기여하는 방안, 그리고 프론트엔드 프레임워크 개발자로서의 성장 로드맵에 대한 아이디어를 공유하겠습니다.

A. Simple-Boot-Front 아키텍처의 장단점

모든 소프트웨어 아키텍처에는 고유한 장점과 단점이 있습니다. Simple-Boot-Front도 예외는 아닙니다.

장점

모듈화된 통합: simple-boot-core의 DI, AOP, 예외 처리 기능과 dom-render의 반응형 UI 기능을 유기적으로 통합하여, 각 영역의 강점을 활용하면서도 개발자에게 일관된 경험을 제공합니다.
선언적 개발: 데코레이터와 HTML 속성을 활용하여 컴포넌트, 라우팅, 스크립트 등을 선언적으로 정의할 수 있어 코드의 가독성과 유지보수성이 높습니다.
유연한 확장성: @Script 데코레이터, 내장 서비스, 커스텀 서비스 개발 등을 통해 프레임워크의 기능을 쉽게 확장하고 재사용 가능한 로직을 추가할 수 있습니다.
경량성: 가상 DOM을 사용하지 않는 dom-render를 렌더링 엔진으로 채택하여, 번들 크기가 작고 런타임 성능이 효율적입니다.
프론트엔드 특화 기능: 쿠키, 로컬 스토리지, 메타 태그 조작 등 프론트엔드 개발에 필수적인 유틸리티 서비스들을 내장하여 개발 편의성을 높입니다.

단점

학습 곡선: simple-boot-core와 dom-render의 개념을 모두 이해해야 하므로, 처음 접하는 개발자에게는 다소 높은 학습 곡선이 존재할 수 있습니다.
생태계: React, Angular, Vue와 같은 대형 프레임워크에 비해 커뮤니티 지원, 플러그인, 개발 도구 등의 생태계가 부족합니다.
디버깅의 복잡성: Proxy 기반의 반응성(dom-render)과 AOP(simple-boot-core)는 코드의 실행 흐름을 가로채기 때문에, 예상치 못한 동작이 발생했을 때 디버깅이 어려울 수 있습니다.
SSR(Server-Side Rendering) 지원: 현재 simple-boot-front는 클라이언트 측 렌더링에 중점을 두고 있으며, SSR에 대한 명시적인 지원은 추가적인 구현이 필요할 수 있습니다.

B. 성능 최적화 및 확장 방안

Simple-Boot-Front를 한 단계 더 발전시키기 위한 몇 가지 아이디어입니다.

번들 최적화: Webpack의 코드 스플리팅, 트리 쉐이킹, 지연 로딩(Lazy Loading) 등을 적극 활용하여 초기 로딩 시간을 단축하고 사용자 경험을 개선할 수 있습니다.
렌더링 성능 개선: dom-render의 Keyed-Diffing 알고리즘을 dr-for-of에 완전히 구현하여 리스트 렌더링 성능을 극대화할 수 있습니다.
SSR 지원: Node.js 환경에서 dom-render를 사용하여 서버 측에서 초기 HTML을 생성하는 SSR 기능을 추가하여 초기 로딩 속도와 SEO를 개선할 수 있습니다.
개발자 도구: 브라우저 확장 형태로 프레임워크 전용 개발자 도구를 만들어 컴포넌트 트리, 상태 변화, 이벤트 흐름 등을 시각화하여 디버깅 편의성을 높일 수 있습니다.
테마/스타일링 시스템: CSS-in-JS 솔루션이나 CSS 변수를 활용한 테마 시스템을 통합하여 스타일링의 유연성을 높일 수 있습니다.

C. 프론트엔드 프레임워크 개발의 미래

프론트엔드 개발은 끊임없이 진화하고 있습니다. Simple-Boot-Front와 같은 프레임워크를 직접 설계하고 구현해 본 경험은 여러분을 이 변화의 선두에 서게 할 것입니다.

Web Components 표준과의 통합: Simple-Boot-Front는 현재 자체 컴포넌트 메커니즘을 사용하지만, 향후 Web Components 표준(Custom Elements, Shadow DOM)과의 통합을 고려하여 브라우저의 기본 기능을 활용하고 상호 운용성을 높일 수 있습니다.
빌드 타임 최적화: Svelte와 같이 빌드 타임에 코드를 분석하여 런타임 오버헤드를 최소화하는 컴파일러 기반 접근 방식을 도입하여 성능을 더욱 향상시킬 수 있습니다.
Edge Computing: 서버리스 환경이나 Edge Computing 환경에서 프론트엔드 로직을 실행하여 사용자에게 더 가까운 곳에서 콘텐츠를 제공하고 지연 시간을 줄이는 방안을 모색할 수 있습니다.
AI 기반 개발 도구: AI를 활용하여 코드 자동 완성, 버그 탐지, 성능 최적화 제안 등 개발 생산성을 혁신적으로 높이는 도구들을 프레임워크에 통합하는 연구가 활발히 진행될 것입니다.

이 책이 여러분의 프론트엔드 프레임워크 개발 여정에 든든한 길잡이가 되었기를 바랍니다. 끊임없이 배우고, 탐구하며, 더 나은 웹 애플리케이션을 만들어가는 즐거움을 만끽하시길 응원합니다.

위 문서는 github 에서 확인 가능합니다

소스 및 구현부는 simple-boot-front github 에서 확인가능합니다

visualkhh@gmail.com

서문: 왜 프론트엔드 프레임워크를 만드는가?

📖 웹 프론트엔드 프레임워크 설계와 구현: SPA 개발을 위한 프론트엔드 아키텍처

제1장: 프레임워크의 시작점 - SimpleBootFront와 옵션

제2장: 컴포넌트 시스템 - UI 구성의 핵심

제3장: 라우팅과 내비게이션 - SPA의 흐름 제어

제4장: 동적 스크립트와 서비스 - 프레임워크 확장

제5장: 프레임워크의 기반 - Simple-Boot Core 연동

부록: 더 나아가기

서문: 왜 프론트엔드 프레임워크를 만드는가?

simple-boot-front의 핵심 특징

이 책에서 다룰 주요 내용

제1장: 프레임워크의 시작점 - SimpleBootFront와 옵션

1.1. SimpleBootFront의 역할과 초기화

1.2. SimFrontOption을 통한 설정 관리

예제: SimpleBootFront 초기화 및 설정

1.3. 의존성 주입(DI) 컨테이너 연동

제2장: 컴포넌트 시스템 - UI 구성의 핵심

2.1. @Component 데코레이터와 컴포넌트 정의

2.2. dom-render와의 통합

SimpleBootFront.initDomRenderTargetElements 메소드

예제: @Component 데코레이터와 dom-render 통합

2.3. 컴포넌트 생명주기

예제: 컴포넌트 생명주기 훅 사용

제3장: 라우팅과 내비게이션 - SPA의 흐름 제어

3.1. @Router와 @Route를 활용한 라우팅

구현 원리

예제: @Router와 @Route를 활용한 라우팅

3.2. $router.go()를 이용한 프로그래밍 방식 내비게이션

구현 원리

3.3. RouterAction을 통한 라우팅 가드

구현 원리

제4장: 동적 스크립트와 서비스 - 프레임워크 확장

4.1. @Script 데코레이터와 동적 스크립트

구현 원리

예제: @Script 데코레이터와 동적 스크립트 사용

4.2. 내장 서비스 활용 (Cookie, Storage, MetaTag)

예제: 내장 서비스 활용

4.3. 커스텀 서비스 개발

예제: 커스텀 서비스 개발

제5장: 프레임워크의 기반 - Simple-Boot Core 연동

5.1. Simple-Boot Core의 DI, AOP, 예외 처리 활용

예제: Simple-Boot Core 기능 활용

5.2. 프론트엔드 환경에 최적화된 통합

부록: 더 나아가기

A. Simple-Boot-Front 아키텍처의 장단점

장점

단점

B. 성능 최적화 및 확장 방안

C. 프론트엔드 프레임워크 개발의 미래

`simple-boot-front`의 핵심 특징

예제: `SimpleBootFront` 초기화 및 설정

2.1. `@Component` 데코레이터와 컴포넌트 정의

2.2. `dom-render`와의 통합

`SimpleBootFront.initDomRenderTargetElements` 메소드

예제: `@Component` 데코레이터와 `dom-render` 통합

3.1. `@Router`와 `@Route`를 활용한 라우팅

예제: `@Router`와 `@Route`를 활용한 라우팅

3.2. `$router.go()`를 이용한 프로그래밍 방식 내비게이션

3.3. `RouterAction`을 통한 라우팅 가드

4.1. `@Script` 데코레이터와 동적 스크립트

예제: `@Script` 데코레이터와 동적 스크립트 사용