이 페이지의 내용
문서API 레퍼런스
API 레퍼런스05

BindModel

모델의 속성, 메서드, 이벤트를 찾아보세요.

한국어 문서약 59분

BindModel은 데이터 처리 및 바인딩 작업을 수행하기 위한 핵심 클래스입니다. 이 클래스는 데이터 테이블 관리, 명령 정의, 콜백 처리 등 다양한 기능을 제공합니다.

구성 요소#

속성#

항목 설명
_columnType 생성될 컬럼의 기본 타입입니다.
_baseTable BindModel 객체의 기본 테이블입니다.
_tables 관리되는 모든 테이블의 컬렉션입니다.
baseConfig 서버 요청에 필요한 기본 설정입니다.
url 기본 요청 경로를 정의합니다.
first 기본적으로 제공되는 MetaTable 입니다.
columns 기본 테이블의 컬럼 컬렉션을 참조합니다.
items 컬럼의 공통 속성을 관리하는 컬렉션입니다.
fn 사용자 정의 함수를 관리하는 컬렉션입니다.
command 명령(BindCommand) 객체를 관리하는 컬렉션입니다.
cbFail 명령 실행 시 유효성 검사에 실패했을 때 호출되는 콜백 함수입니다.
cbError 명령 실행 중 오류가 발생했을 때 호출되는 콜백 함수입니다.
cbBaseBegin 명령 실행 흐름에서 첫 번째로 호출되는 기본 콜백 함수입니다.
cbBaseValid 유효성 검사 전에 호출되는 기본 콜백 함수입니다.
cbBaseBind 명령 실행 시 데이터를 서버로 전송하기 전에 호출되는 기본 콜백 함수입니다.
cbBaseResult 전송받은 서버 응답 데이터를 처리하는 기본 콜백 함수입니다.
cbBaseOutput 서버 응답 데이터를 화면에 출력하는 기본 콜백 함수입니다.
cbBaseEnd 명령 실행이 완료된 후 호출되는 기본 콜백 함수입니다.
preRegister init() 메소드를 실행할 때 처음으로 호출되는 콜백함수입니다.
preCheck init() 메소드를 실행할 때 전처리 검사를 수행하는 콜백 함수입니다.
preReady init() 메소드를 실행할 때 전처리 검사(preCheck) 이후에 수행하는 콜백함수입니다.

메소드#

항목 설명
addTable() 새로운 테이블(MetaTable)을 추가합니다.
addCommand() 새로운 명령(BindCommand)을 추가합니다.
addColumn() 테이블에 새로운 컬럼을 추가합니다.
addColumnValue() 테이블에 컬럼을 추가하면서 해당 컬럼의 기본값을 설정합니다.
setService() 서비스 객체를 주입하여 BindModel 객체를 구성합니다.
setMapping() 지정된 명령(BindCommand)의 뷰에 컬럼을 매핑합니다.
init() BindModel 객체를 초기화하는 메서드입니다.
checkSelector() selector 속성을 검사하여 유효하지 않은 항목을 반환합니다.
getSelector() 대상 컬렉션에 설정된 selector 객체를 반환합니다.

이벤트#

항목 설명
onExecute 명령(BindCommand)이 실행되기 전에 호출되는 전역 이벤트 입니다.
onExecuted 명령(BindCommand)이 실행된 후 호출되는 전역 이벤트 입니다.

주요 속성#

_columnType#

생성될 컬럼의 기본 타입 속성입니다.

ts
type _columnType = HTMLColumn | MetaColumn | CustomColumn;
  • HTMLColumn: HTML 요소와 연동 가능한 컬럼 타입
  • MetaColumn: MetaTable 의 기본 컬럼 타입
  • CustomColumn: 사용자 정의 컬럼 타입

_columnType 속성은 새로운 컬럼을 추가할 때 적용되는 기본 타입입니다.

  • 객체 생성 시 HTMLColumn으로 초기화됩니다. (기본값)
  • MetaColumn을 상속하여 사용자 정의 타입을 구현할 수 있습니다.

유의점: _columnType 속성을 변경하면 이후 추가되는 컬럼부터 적용됩니다.

기본값 확인 및 변경 예제

js
const bm = new BindModel();

console.log(bm._columnType); // [Class HTMLColumn]

// 컬럼 타입 변경
bm._columnType = MetaColumn; 
console.log(bm._columnType); // [Class MetaColumn]
  • _columnType을 MetaColumn으로 변경하고 변경된 값을 확인합니다.

컬럼 생성 시 _columnType 적용 예제

js
const bm = new BindModel();

// 기본 컬럼 타입으로 컬럼 추가
bm.addColumn('username');
console.log(bm.columns['username']); // [Object HTMLColumn]

// _columnType 변경 후 컬럼 추가
bm._columnType = MetaColumn;
bm.addColumn('age');

console.log(bm.columns['age']);     // [Object MetaColumn]
  • _columnType을 변경 후 새로운 컬럼을 추가하면 변경된 타입으로 추가됩니다.

#이슈

  • 별도로 테이블의 columns.baseType 을 임의 로 지정한 경우
  • 설정 이후에 테이블을 추가한 경우

_baseTable#

BindModel 객체의 기본 테이블 속성입니다.

ts
type _baseTable = MetaTable;
  • MetaTable: BindModel의 기본 테이블

힌트 first === _tables[0] === _tables['frist']

_baseTable 속성은 데이터를 관리하는 기본 테이블로, 명령과 컬럼 매핑의 중심 역할을 수행합니다. 컬럼 추가 및 명령 실행 시 기본적으로 적용되는 테이블입니다.

  • 객체 생성 시 초기값으로 _tables['first']객체가 _baseTable로 설정됩니다. (초기값)
  • columns 속성은 항상 _baseTable.columns을 참조합니다.

Tip : 관련 메소드

  • addCommand(): 명령 생성 시 기본 테이블로 사용됩니다.
  • addColumn(): 컬럼을 추가할 때 기본테이블로 사용됩니다.
  • addColumnValue(): 초기값을 포함된 컬럼을 추가할 때 기본 테이블로 사용됩니다.
  • setMapping(): 컬럼 매핑 작업에서 기본 테이블로 사용됩니다.

기본테이블 변경 예제

js
const bm = new BindModel();

// 새로운 테이블 추가
bm.addTable('second');

// 기본 테이블 변경
bm._baseTable = bm.second;

// 변경된 기본 테이블에 컬럼 추가
bm.addColumn('username');

console.log(bm.second.columns['username']); // [Object HTMLColumn]
console.log(bm.columns['username']);        // [Object HTMLColumn]
  • _baseTable을 second 테이블로 변경하여 이후의 모든 데이터 작업이 이를 기준으로 수행됩니다.
  • addColumn('username')을 호출하면, 변경된 _baseTable인 second 테이블에 컬럼이 추가됩니다.
  • bm.columns는 항상 _baseTable.columns을 참조하므로, 변경된 기본 테이블의 컬럼과 동일한 결과를 출력합니다.

_tables#

관리되는 모든 테이블의 컬렉션 속성입니다.

ts
type _tables = MetaTableCollection;
  • MetaTableCollection: 테이블 객체의 컬렉션

_tables 속성은 복수의 테이블을 관리하는 컬렉션으로 사용됩니다.

  • BindModel 객체 생성 시 기본 테이블로 _tables['first']가 자동으로 생성됩니다.
  • addTable() 메서드를 사용하여 새로운 테이블을 추가할 수 있습니다.
  • 테이블명 또는 인덱스를 통해 각 테이블에 접근할 수 있습니다.
  • _tables 컬렉션의 다른 테이블로 _baseTable속성을 변경할 수 있습니다.

참조 : first === _tables['first'] === _tables[0]

js
const bm = new BindModel();

// 테이블 추가
bm.addTable('second');
bm.addTable('three');

// 테이블 이름으로 접근
console.log(bm._tables['first']);  // [Object MetaTable "first"] *기본 테이블*
console.log(bm._tables['second']); // [Object MetaTable "second"]
console.log(bm._tables['three']);  // [Object MetaTable "three"]

// 테이블 인덱스로 접근
console.log(bm._tables[0]); // [Object MetaTable "first"] *기본 테이블*
console.log(bm._tables[1]); // [Object MetaTable "second"]
console.log(bm._tables[2]); // [Object MetaTable "three"]
  • addTable() 메서드를 사용해 추가 테이블을 생성합니다.
  • 각 테이블은 _tables 컬렉션에 저장되며, 테이블명이나 인덱스를 통해 접근할 수 있습니다.
  • _tables['first']는 초기에 기본 테이블이며, 추가된 테이블은 순서대로 인덱스를 가집니다.

baseConfig#

서버 요청에 필요한 기본 설정 속성입니다.

ts
type baseConfig = {
    method: 'GET' | 'POST' | 'PUT' | 'DELETE',
    url?: string,
    baseUrl?: string,
	responseType?: 'json' | 'text' | 'blob'
};
  • method: HTTP 요청 방식 (기본값 'GET')
  • url: 요청 경로
  • baseUrl: url 과 결합되는 기본 경로(도메인)
  • responseType: 서버 응답 데이터 형식 (기본값 'json')

참조 : 추가 속성에 대한 자세한 내용은 Axios의 config 문서를 참조하세요.

baseConfig 속성은 서버 요청의 기본 설정을 관리합니다.

  • 명령별로 config 설정을 하지 않으면 baseConfig 설정이 사용됩니다.
  • baseConfig 속성은 axios 설정(config)의 역활을 수행하며 URL, HTTP 메서드, 응답 데이터 형식 등 주요 설정 값을 지정합니다.

Tip: basConfig를 활용하여 인증 토큰 추가, 요청 데이터 포맷 지정, 서버와의 세부 통신 방식을 효율적으로 관리할 수 있습니다.

js
const bm = new BindModel();

bm.baseConfig = {
    url: '/api/data',
    method: 'POST',
    responseType: 'json',
    headers: { Authorization: 'Bearer token' }
};
  • baseConfig 속성에 서버 요청 URL, HTTP 메서드, 응답 형식, 헤더를 설정합니다.

url#

기본 요청 경로를 정의하는 속성입니다.

ts
type url = string;
  • url: 서버 요청 경로

url 속성은 서버 요청의 기본 경로의 역할을 합니다.

  • url 속성은 baseConfig.url속성의 참조값입니다.
  • 각 명령(BindCommand)에서 url 속성을 설정하면 BindModel의 url 속성은 무시됩니다.
  • baseConfig.baseUrl 속성과 조합하여 전체 URL을 구성할 수 있습니다. (도메인)

기본 url 설정 예제

js
const bm = new BindModel();
bm.url = '/api/users';

console.log(bm.baseConfig); // Out: { url: '/api/users' }
  • 설정된 URL은 baseConfig 속성에 반영되어 명령에서 기본 설정으로 사용됩니다.

명령에서 url 사용시 예제

js
const bm = new BindModel();
bm.url = '/users';

// 명령 추가
bm.addCommand('cmd1');
bm.addCommand('cmd2');

// 경로 설정
bm.command['cmd2'].url = '/api';

// 명령 실행
bm.command['cmd1'].execute(); // 요청 경로 : '/users'
bm.command['cmd2'].execute(); // 요청 경로 : '/api'
  • cmd1 명령은 기본 URL을 사용하고, cmd2 명령는 개별적으로 설정된 URL을 사용하여 실행합니다.

first#

기본적으로 제공되는 MetaTable 속성입니다.

ts
type first = MetaTable;
  • MetaTable: 모델에서 생성한 테이블

Tip : first ==== _baseTable === _tables['first'] === _tables[0]

first 속성은 BindModel 객체에서 기본 테이블(_baseTable)을 참조합니다.

  • BindModel 객체가 생성되면 자동으로 first 테이블이 생성됩니다.
  • _baseTable 속성은 초기값으로 _tables['first']를 가리킵니다.
  • first 테이블은 _tables['first'], _tables[0] 과 동일합니다.
js
const bm = new BindModel();

// 테이블에 컬럼 추가
bm.first.columns.add('id');
bm.first.columns.add('username');

console.log(bm.first.columns['username']);            // [Object HTMLColumn]
console.log(bm._baseTable.columns['username']);       // [Object HTMLColumn]
console.log(bm._tables['first'].columns['username']); // [Object HTMLColumn]
console.log(bm.columns['username']);                  // [Object HTMLColumn]
  • first 속성을 사용하여 기본 테이블에 컬럼과 데이터를 추가합니다.

columns 또는 cols#

기본 테이블의 컬럼 컬렉션을 참조하는 속성입니다.

별칭으로 cols 참조 속성을 제공합니다.

ts
type columns = MetaTableColumnCollection;
  • MetaTableColumnCollection: MetaTable 의 컬럼 컬렉션

columns 속성은 기본 테이블의 컬럼 컬렉션(_baseTable.columns)을 가르킵니다.

  • _baseTable 속성이 변경되면, columns 속성의 참조값도 변경됩니다.

Tip : 자주 사용되는 기본 테이블의 컬렉션에 쉽게 접근할 수 있습니다.

컬럼 컬렉션에서 컬럼 추가 예제

js
const bm = new BindModel();

bm.columns.add('username');

console.log(bm.columns['username']); // [Object HTMLColumn]
  • columns 속성을 사용해 기본 테이블에 컬럼을 추가합니다.

기본 테이블 변경 시 컬럼 추가 예제

js
const bm = new BindModel();

// 기본 테이블에 컬럼 추가
bm.columns.add('email');

// 기본 테이블 변경
bm._baseTable = bm.addTable('second');

// 새로운 테이블에 컬럼 추가
bm.columns.add('age');

console.log(bm.first.columns['email']);  // [Object HTMLColumn]
console.log(bm.second.columns['age']);   // [Object HTMLColumn]
console.log(bm.columns['age']);          // [Object HTMLColumn]
  • _baseTable 속성이 변경되면 columns 속성이 새로운 테이블의 컬럼 컬렉션을 참조하게 됩니다.
  • bm.columns['age'] === bm.second.columns['age'] 동일합니다.

items#

컬럼의 공통 속성을 관리하는 컬렉션 속성입니다.

ts
type items = PropertyCollection;
  • PropertyCollection: 키-값 쌍으로 구성된 컬렉션

items 속성은 컬럼의 공통 속성을 관리하는 컬렉션입니다.

  • 서비스 객체를 구성할 때 컬럼을 공통 속성으로 등록하고 사용합니다.

Tip: items 속성은 복수의 테이블에 동일한 컬럼을 등록하는데 유용합니다.

items 속성에 추가 예제

js
const bm = new BindModel();

// items 추가
bm.items.add('username', 'Alice');
bm.items.add('id', { value: 3, default: 0 });

// 속성 조회
console.log(bm.items['username']); // Out: 'Alice'
console.log(bm.items['id']);       // Out:  { value: 3, default: 0 }
  • items 컬렉션에 속성을 추가하고 키로 조회하여 값을 확인합니다.
  • items 값이 string, number, boolean 타입이면 컬럼의 value 속성으로 지정되고, 객체인 경우 각 속성에 매칭됩니다.

items 속성과 테이블 매핑 예제

js
const bm = new BindModel();

// 새로운 테이블 추가
bm.addTable('second');

// items 추가
bm.items.add('aa', 10);
bm.items.add('bb', 20);

// 테이블 매핑 설정
bm.setMapping({
    'aa': {},
    'first.bb': {},
    'second.bb': {}
});

// 속성 및 컬럼 상태 확인
console.log(bm.items.count); // Out: 2
console.log(bm.first.columns.count);  // Out: 2
console.log(bm.second.columns.count); // Out: 1
console.log(bm.first.columns['aa'].value);  // Out: 10
console.log(bm.first.columns['bb'].value);  // Out: 20
console.log(bm.second.columns['bb'].value); // Out: 20
  • '테이블명 . 아이템' 형식으로 지정하면 해당 테이블에 등록됩니다.
  • '아이템명' 형식으로 테이블명을 생략하면 기본 테이블에 등록됩니다.
  • first 테이블에는 aa, bb 컬럼이 추가되고, second 테이블에는 bb 컬럼이 추가됩니다.

참조 : setMaping 메소드


fn#

사용자 정의 함수를 관리하는 컬렉션 속성입니다.

ts
type fn = PropertyCollection;
  • PropertyCollection: 키-값 쌍으로 구성된 컬렉션

fn 속성은 사용자 정의 함수를 관리하는 컬렉션입니다.

Tip: 콜백함수에서 호출되는 함수를 fn 컬렉션에 정의하여 BindModel을 캡슐화할 수 있습니다.

js
const bm = new BindModel();

// 사용자 정의 함수 추가
bm.fn.add('calculateSum', (a, b) => a + b);

// 콜백함수에서 호출
bm.cbBaseBegin = function(model, cmd) {
	bm.fn.calculateSum(5, 10);
};

console.log(bm.fn['calculateSum'](5, 10)); // Out: 15
  • 콜백함수 또는 외부에서 fn 함수를 호출할 수 있습니다.

command 또는 cmd#

명령(BindCommand) 객체를 관리하는 컬렉션 속성입니다.

별칭으로 cmd 참조 속성을 제공합니다.

ts
type command = PropertyCollection;
  • PropertyCollection: 키-값 쌍으로 구성된 컬렉션

command 속성은 명령(BindCommand) 객체를 관리하는 컬렉션입니다.

  • command['명령 이름'] 또는 command[인덱스] 경로를 통해 접근할 수 있습니다.
  • addCommand() 메서드를 사용하여 새로운 명령(BindCommand)을 추가할 수 있습니다.

참조 : addCommand() 메소드

js
const bm = new BindModel();

// 명령 추가
bm.addCommand('cmd1');

// 명령 실행
bm.command['cmd1'].execute();
bm.cmd['cmd1'].execute();
bm.cmd[0].execute();
  • command['cmd1'], cmd['cmd1'], cmd[0] 을 통해 명령 객체에 접근할 수 있습니다.

cbFail#

명령 실행 시 유효성 검사에 실패했을 때 호출되는 콜백 함수입니다.

ts
type cbFail = (msg: string, valid: MetaView) => void;
  • msg: 유효성 검사 실패와 관련된 메시지
  • valid: 실패한 유효성 검사가 적용된 MetaView 객체

cbFail 속성은 명령 실행 중 유효성 검사 실패를 처리하기 위한 콜백 함수입니다.

  • 유효성 검사가 실패하면 cbFail 함수가 호출됩니다.
  • 사용 환경에 맞게 cbFail 함수를 재정의하여 사용할 수 있습니다.
  • 기본 콜백함수에서 콘솔 출력을 제공합니다. (기본값)
js
const bm = new BindModel();

bm.cbFail = function (msg, view) {
    console.warn(`failed: ${msg}`);
};
  • cbFail 함수를 설정하여 유효성 검사 실패 시 경고 메시지를 출력합니다.

cbError#

명령 실행 중 오류가 발생했을 때 호출되는 콜백 함수입니다.

ts
type cbError = (msg: string, status?: number, response?: object) => void;
  • msg: 오류 메시지
  • status(선택): HTTP 상태 코드 또는 오류 상태를 나타내는 숫자 값
  • response(선택): 서버에서 반환된 응답 객체

cbError 속성은 명령 실행 중 발생하는 모든 예외 상황을 처리하기 위한 콜백함수입니다.

  • 사용자에게 오류 메시지를 제공하거나 로그를 출력하여 문제를 확인할 수 있습니다.
  • 사용 환경에 맞게 cbError을 재정의하여 사용할 수 있습니다.
  • 기본 콜백함수에서 콘솔 출력을 제공합니다.

Tip : execute() 메서드는 try 문으로 구성되어 있으며, catch 블럭에서 cbError 콜백 함수가 호출됩니다.

전역 오류 처리 예제

js
const bm = new BindModel();

bm.cbError = function(msg, status, response) {
    console.error(`Error occurred: ${msg}`);
    if (status) console.log(`Status: ${status}`);
    if (response) console.log(`Response:`, response);
};

// 명령 실행 중 오류가 발생하면 cbError가 호출됩니다.
  • 오류발생 시 오류 메시지와 상태, 응답 데이터를 로그로 출력합니다.

사용자 정의 오류 처리 예제

js
const bm = new BindModel();

bm.cbError = function(msg, status, response) {
    alert(`An error occurred: ${msg}`);
};

// 명령 실행 중 오류가 발생하면 사용자에게 알림 메시지를 표시합니다.
  • cbError를 재정의하여 오류 발생 시 알림 창이 표시됩니다.

cbBaseBegin#

명령 실행 흐름에서 첫 번째로 호출되는 기본 콜백 함수입니다.

ts
type cbBaseBegin = (model: BindModel, cmd: BindCommand) => void;
  • model : 현재 모델(BindModel) 객체 입니다.
  • cmd: 실행 중인 명령(BindCommand) 객체

cbBaseBegin은 명령 실행 흐름에서 첫 번째로 호출되는 콜백 함수입니다.

  • 명령 실행 전에 필요한 설정을 동적으로 설정할 수 있습니다.
  • 명령별로 cbBegin 콜백 함수가 없으면 cbBaseBegin 콜백 함수가 호출됩니다.
js
const bm = new BindModel();

bm.cbBaseBegin = function (model, cmd) {
    console.log(`Command is about to execute.`);
    // Out: `Command "XXX" is about to execute.`
};
  • cbBaseBegin 함수를 설정하여 명령 실행 전 로그 메시지를 출력합니다.

cbBaseValid#

유효성 검사 전에 호출되는 기본 콜백 함수입니다.

ts
type cbBaseValid = (valid: MetaView, cmd: BindCommand, model: BindModel) => boolean | undefined;
  • view: 유효성 검사 대상인 MetaView 객체
  • cmd: 실행 중인 명령(BindCommand) 객체
  • model : 현재 모델(BindModel) 객체 입니다.
  • 반환값:
    • true: 유효성 검사를 통과하고 다음 단계로 진행합니다.
    • false: 유효성 검사가 실패하며, cbFail 함수가 호출됩니다.
    • undefined: 유효성 검사가 실패하지만, cbFail 함수는 호출되지 않습니다.

cbBaseValid는 명령 실행 중 데이터의 유효성을 검사하기 전에 호출됩니다.

  • 명령별로 cbValid 콜백 함수가 없으면 cbBaseValid 콜백 함수가 호출됩니다.

Tip : 기본 유효성 검사 로직 외에 추가적인 검증 로직을 적용할 수 있습니다.

유효성 검사 예제

js
const bm = new BindModel();

bm.addCommand('cmd1');
bm.addColumn('username', 'cmd1', 'valid');

// 콜백 함수 설정
bm.cbBaseValid = function (view, cmd, model) {
	const username = view.columns['username'].value;
    if (!username || username.length < 3) {
        alert('사용자 이름은 3자 이상이어야 합니다.');
        return false;
    }
    return true;
};

// 명령 실행
bm.command['cmd1'].execute();
  • 유효성 검사를 통해 username 값이 3자 이상인지 확인합니다.

cbBaseBind#

명령 실행 시 데이터를 서버로 전송하기 전에 호출되는 기본 콜백 함수입니다.

ts
type cbBaseBind = (
    bind: MetaView, 
    cmd: BindCommand, 
    config: object
) => void;
  • bind: 서버로 전송할 데이터를 포함하는 MetaView 객체
  • cmd: 실행 중인 명령(BindCommand) 객체
  • config: axios 요청 설정 객체

cbBaseBind는 명령 실행 중 서버 요청 데이터를 준비하기 위해 호출됩니다.

  • 서버로 데이터를 전송하기 전에 요청 설정을 동적으로 설정할 수 있습니다.
  • 명령별로 cbBind 콜백 함수가 없으면 cbBaseBind 콜백 함수가 호출됩니다.

Tip: 전송할 데이터의 암호화 또는 토큰 추가 등 데이터 포멧 변환에 활용할 수 있습니다.

js
const bm = new BindModel();

bm.addCommand('sendData');

// 콜백 함수 설정
bm.cbBaseBind = function(bind, cmd, config) {
    config.headers = {
        Authorization: 'Bearer token'
    };
};

// 명령 실행
bm.command['sendData'].execute();
  • 실행 시점에서 서버 요청 헤더에 인증 토큰을 동적으로 추가합니다.

cbBaseResult#

전송받은 서버 응답 데이터를 처리하는 기본 콜백 함수입니다.

ts
type cbBaseResult = (
    data: object, 
    cmd: BindCommand, 
    response: object
) => object;
  • data: 서버 응답 데이터
  • cmd: 실행된 명령(BindCommand) 객체
  • response: 서버에서 반환된 전체 응답 객체
  • 반환값: 처리된 데이터를 반환하며, 이 데이터는 이후 작업에 사용됩니다.

cbBaseResult는 서버에서 반환된 데이터를 검증하거나 변환하는 데 사용됩니다.

  • 서버 응답 데이터를 MetaView 스키마 형식으로 변환하는데 사용됩니다.
  • 내부적으로 반환된 데이터는 MetaView(output)의 read(data) 메소드에 전달됩니다.
  • 명령별로 cbResult 콜백 함수가 없으면 cbBaseResult 콜백 함수가 호출됩니다.

참조 : MetaView 의 read()

js
const bm = new BindModel();

bm.addCommand('cmd1', 1);

// 콜백 함수 설정
bm.cbBaseResult = function(data, cmd, response) {
    return { rows: data.rows.filter(product => product.inStock) };
};

// 명령 실행
bm.command['cmd1'].execute();
  • 서버 응답 데이터에서 inStock 값이 참인 상품만 필터링하여 반환합니다.

cbBaseOutput#

서버 응답 데이터를 화면에 출력하는 기본 콜백 함수입니다.

ts
type cbBaseOutput = (
    outputs: MetaViewCollection, 
    cmd: BindCommand, 
    response: object
) => object;
  • outputs: 매핑된 데이터를 포함하는 MetaViewCollection 객체
    • outputs[0] 은 output속성을 가르킵니다.
    • outputs[뷰 이름] 또는 outputs[인덱스]을 통해서 뷰에 접근합니다.
  • cmd: 현재 실행 중인 BindCommand 객체
  • response: axios 응답 객체

cbBaseOutput는 명령 실행 시 output 뷰에 데이터를 매핑한 뒤 호출됩니다.

  • outputOption이 1, 2, 3 일 경우에만 호출됩니다.
  • 응답 데이터를 기반으로 화면에 출력하거나 로그를 기록할 수 있습니다.
  • 명령별로 cbOutput 콜백 함수가 없으면 cbBaseOutput 콜백 함수가 호출됩니다.

참조 : 명령 복수 출력 구성

js
const bm = new BindModel();

bm.addCommand('cmd1', 1); // 모든 컬럼의 데이터 가져옴

// 콜백 함수 설정
bm.cbBaseOutput = function(outputs, cmd, response) {
    const output = outputs[0]; // 첫번째 기본 MetaView 선택
    output.rows.forEach(product => {
        console.log(`Product ID: ${product.id}, Name: ${product.name}`);
    });
};

bm.command['cmd1'].execute();
// Product ID: XXX , Name: XXX
// ...
  • 명령 실행 후 첫 번째 MetaView에서 데이터를 가져와 각 제품의 ID와 이름을 출력합니다.

cbBaseEnd#

명령 실행이 완료된 후 호출되는 기본 콜백 함수입니다.

ts
type cbBaseEnd = (
    status: number, 
    cmd: BindCommand, 
    response: object
) => void;
  • status: 명령 실행 결과를 나타내는 상태 코드
  • cmd: 현재 실행된 BindCommand 객체
  • response: 서버에서 반환된 응답 객체

cbBaseEnd는 명령 실행 후 호출되어 최종 결과를 처리하는 콜백 함수입니다.

  • 명령 실행 후 후속 작업을 수행할 수 있습니다.
  • 명령별로 cbEnd 콜백 함수가 없으면 cbBaseEnd 콜백 함수가 호출됩니다.
js
const bm = new BindModel();

bm.addCommand('saveData');

// 콜백 함수 설정
bm.cbBaseEnd = function(status, cmd, response) {
    if (status > 0) alert('데이터 저장이 완료되었습니다.');
    else alert('데이터 저장 중 오류가 발생했습니다.');
};

bm.command['saveData'].execute();
  • 성공 여부에 따라 후속 작업이나 오류 처리를 수행할 수 있습니다.

preRegister#

init() 메소드를 실행할 때 처음으로 호출되는 콜백함수입니다.

ts
type preRegister = (model: BindModel) => void;
  • model: 현재 실행되는 BindModel 객체

Tip : init() 메소드를 필요에 따라 선택적으로 사용할 수 있습니다.

preRegister 콜백함수는 BindModel 객체의 초기화 과정에서 처음으로 호출되며, 기본적으로 필요한 컬럼, 명령 등을 등록하거나 설정합니다.

js
const bm = new BindModel();

bm.preRegister = function (model) {
    console.log('Registering the model...');
};

bm.init();
// Out: 'Registering the model...'
  • init() 메서드를 호출하면 preRegister 함수가 실행되며, 초기화 작업의 시작을 확인할 수 있습니다

preCheck#

init() 메소드를 실행할 때 전처리 검사를 수행하는 콜백 함수입니다.

ts
type preReady = (model: BindModel) => boolean;
  • model: 현재 실행되는 BindModel 객체
  • 반환값: 
    • true이면 유효성 검사를 통과하고 초기화가 계속 진행됩니다. 
    • false이면 초기화가 중단됩니다.

Tip: init() 메소드를 필요에 따라 선택적으로 사용할 수 있습니다.

preCheck 콜백함수는 BindModel 객체 초기화 과정에서 preRegister 이후 실행되며, 전처리 검사를 수행한 결과에 따라 다음 단계로 진행 여부를 결정합니다.

  • 객체 상태 및 실행 환경에 관련된 검사를 수행합니다.

Tip: items 또는 columns 의 selector 속성의 HTML 유효성 검사 활용할 수 있습니다.

js
const bm = new BindModel();

bm.preCheck = function (model) {
    const result = model.checkSelector();  // selector 속성의 유효성 검사
    if (result.length > 0) console.error('selector fail...');
    return true;
};

bm.init();
// Out: 'selector fail...'
  • preCheck 콜백을 설정하여 초기화 전에 selector 속성의 유효성을 검사합니다.

preReady#

init() 메소드를 실행할 때 전처리 검사(preCheck) 이후에 수행하는 콜백함수입니다.

ts
type preReady = (model: BindModel) => void;
  • model: 현재 실행되는 BindModel 객체

Tip: init() 메소드를 필요에 따라 선택적으로 사용할 수 있습니다.

preReady 콜백함수는 BindModel 객체의 전처리(preCheck) 검사가 성공한 경우 실행됩니다.

  • 초기화가 완료된 후, 필요한 이벤트 연결 등 후속 작업을 수행합니다.

Tip: 전처리 과정은 preRegister와 유사하지만, 논리적으로 preCheck 검사를 통과한 이후에 실행됩니다.

js
const bm = new BindModel();

bm.preReady = function (model) {
    console.log('ready...');
};

bm.init();
// Out: 'read...'
  • preReady 함수를 설정하여 초기화가 완료된 후 콘솔에 출력합니다.

주요 메소드#

addTable()#

새로운 테이블(MetaTable)을 추가하는 메서드입니다.

ts
declare function addTable(name: string): MetaTable;
  • name: 새로 추가될 테이블의 이름
  • 반환값: 생성된 MetaTable 객체를 반환합니다.

addTable() 메서드는 다음과 같은 역할과 특징을 가지고 있습니다:

  • 지정한 이름으로 새로운 MetaTable 객체를 생성하여 _tables 컬렉션에 추가합니다.
  • 테이블 이름은 BindModel 객체의 속성으로 추가되며, 예약어와 중복되지 않아야 합니다.
  • 새로 추가된 테이블은 필요에 따라 기본테이블(_baseTable)로 설정할 수 있습니다.

Tip: 예약어 목록 _tables, _baseTable, _columnType, items, fn, command, cmd, columns, $service, baseConfig, url, _guid, _type, $event, $KEYWORD

js
const bm = new BindModel();

bm.addTable('second');

bm._tables['first'] === bm.first   // true
bm._tables['second'] === bm.second // true
  • addTable() 메서드를 사용하여 second 테이블을 추가합니다.

addCommand()#

새로운 명령(BindCommand)을 추가하는 메서드입니다.

ts
declare function addCommand(
	cmdName: string, 
	outputOption?: number = 0, 
	bTable?: string | MetaTable
): BindCommand;
  • cmdName: 명령 이름 문자열
  • outputOption(선택): 서버 응답 데이터를 출력 뷰에 바인딩하는 방식
    • 0 : 바인딩하지 않음. (기본값)
    • 1 : 응답 데이터를 모든 컬럼과 행으로 가져옴
    • 2 : output.columns 컬렉션에 정의된 컬럼과 매칭되는 데이터를 가져옴
    • 3 : 옵션 2 처리 후, 지정한 인덱스 데이터(rows)를 컬럼값(value)으로 설정
  • bTable(선택): 명령의 기본 테이블(_baseTable)로 사용할 테이블 (기본값 : 모델의 _baseTable)
  • 반환값: 생성된 BindCommand 객체를 반환합니다.

addCommand() 메소드는 명령(BindCommand) 객체를 생성하고, 이를 command 컬렉션에 등록합니다.

  • outputOption 값을 지정하여 서버 응답 데이터를 출력 뷰 output(MetaView)에 바인딩하는 방식을 설정할 수 있습니다.

참조 : BindModel 클래스의 outputOpion 속성

명령 추가 예제

js
const bm = new BindModel();

bm.addCommand('create');
bm.addCommand('read', 3);

console.log(bm.command['create'].outputOption);  // { option: 0, index: 0 }
console.log(bm.command['read'].outputOption);    // { option: 3, index: 0 }
  • create와 read 명령을 추가하며, 각각 기본 옵션(0)과 출력 옵션(3)으로 설정합니다.

테이블 지정 명령 추가 예제

js
const bm = new BindModel();

bm.addTable('second');

bm.addCommand('create', 0, 'second');

console.log(bm.command['create']);               // [Object BindCommand]
console.log(bm.command['create'].outputOption);  // { option: 0, index: 0 }
console.log(bm.command['create']._baseTable);    // [Object MetaTable "second"]
  • 명령 추가 시 옵션을 0으로 지정하고, 기본 테이블을 second 테이블로 설정하였습니다.

addColumn()#

테이블에 새로운 컬럼을 추가하는 메서드입니다.

ts
type ViewType = '$all' | 'valid' | 'bind' | 'output' | 'misc' | string;

declare function addColumn(
    column: string | MetaColumn,
    cmds?: string | string[] | '$all', 
    views?: ViewType | ViewType[],
    bTable?: MetaTable | string
): void;
  • column: 추가할 컬럼의 이름(문자열) 또는 MetaColumn 객체
  • cmds(선택): 컬럼을 연계할 명령의 이름 또는 이름 배열
  • views(선택): 컬럼을 매핑할 뷰를 이름 또는 이름 배열
    • '$all': 모든 뷰 (기본값)
    • 'valid': 유효성 검사를 위한 뷰
    • 'bind': 서버 요청 데이터를 위한 뷰
    • 'output': 응답 데이터를 매핑하는 뷰
    • 'misc': 추가적인 뷰
    • string: 사용자 정의 출력 뷰
  • bTable(선택): 컬럼을 추가할 MetaTable 객체 (기본값은 _baseTable)

Tip : column 인자만 지정하면 뷰에 매핑은 하지 않고 기본테이블에 컬럼만 추가됩니다.

addColumn() 메서드는 컬럼을 추가하고, 명령(cmd)과 뷰(views)를 지정하여 참조값을 등록할 수 있습니다.

  • column 인자만 지정하여 컬럼을 테이블에 추가할 수 있습니다.
  • cmd와 views 인자를 지정하여 명령(BindCommand)의 뷰에 컬럼을 매핑할 수 있습니다.
  • views인자는 기본적으로 전체 뷰가 지정되어 있습니다. (기본값 '$all')

컬럼 추가 예제

js
const bm = new BindModel();

// 컬럼 추가
bm.addColumn('gender');

console.log(bm.columns['gender']);                   // [Object HTMLColumn]
console.log(bm.first.columns['gender']);             // [Object HTMLColumn]
console.log(bm._tables['first'].columns['gender']);  // [Object HTMLColumn]
  • gender 컬럼이 _baseTable 에 등록되고, columns 속성과 first 속성으로 확인할 수 있습니다.

컬럼 추가 및 모든 뷰에 매핑 예제

js
// 명령 등록
bm.addCommand('cmd1');

// 컬럼 추가 및 명령에 매핑
bm.addColumn('username', 'cmd1');

console.log(bm.cmd['cmd1'].valid.columns['username']);  // [Object HTMLColumn]
console.log(bm.cmd['cmd1'].bind.columns['username']);   // [Object HTMLColumn]
console.log(bm.cmd['cmd1'].output.columns['username']); // [Object HTMLColumn]
console.log(bm.cmd['cmd1'].misc.columns['username']);   // [Object HTMLColumn]
  •  username 컬럼을 모든 뷰(valid, bind, output, misc)에 참조값이 등록됩니다.

컬럼 추가 및 특정 뷰에 매핑 예제

js
// 컬럼 추가 및 명령에 매핑
bm.addColumn('email', 'cmd1', 'valid');
bm.addColumn('phone', 'cmd1', ['bind','output']);

console.log(bm.command['cmd1'].valid.columns['email']);  // [Object HTMLColumn]
console.log(bm.command['cmd1'].bind.columns['phone']);   // [Object HTMLColumn]
console.log(bm.command['cmd1'].output.columns['phone']); // [Object HTMLColumn]
  • email 컬럼을 valid 뷰에만 매핑되고,
  • phone 컬럼은 bind와 output 뷰에 매핑됩니다.

사용자 정의 출력 뷰에 추가 예제

js
// 출력 뷰 추가
bm.command['cmd1'].newOutput('out2');

// 컬럼 추가 및 명령에 매핑
bm.addColumn('address', 'cmd1', 'out2');

console.log(bm.command['cmd1'].out2.columns['address']); // [Object HTMLColumn]
  • 추가된 출력 뷰(out2)에 address 컬럼이 매핑됩니다.

addColumnValue()#

테이블에 컬럼을 추가하면서 해당 컬럼의 기본값을 설정하는 메서드입니다.

ts
declare function addColumnValue(
    columnName: string, 
    value: string | number | boolean | object,
    cmds?: string | string[], 
    views?: '$all' | 'valid' | 'bind' | 'output' | 'misc' | string[],
    bTable?: string | MetaTable
): void;
  • columnName: 추가할 컬럼의 이름
  • value: 초기값으로 설정할 데이터
  • cmds(선택): 컬럼을 연계할 명령의 이름 또는 이름 배열
  • views(선택): 컬럼을 매핑할 뷰를 이름 또는 이름 배열
    • '$all': 모든 뷰 (기본값)
    • 'valid': 유효성 검사를 위한 뷰
    • 'bind': 서버 요청 데이터를 위한 뷰
    • 'output': 응답 데이터를 매핑하는 뷰
    • 'misc': 추가적인 뷰
    • string[]: 사용자 정의 출력 뷰
  • bTable(선택): 컬럼을 추가할 MetaTable 객체 (기본값은 _baseTable)

addColumnValue() 메서드는 컬럼을 추가하면서 초기값을 설정하고, 명령(cmd)과 뷰(views)를 지정하여 참조값을 등록할 수 있습니다.

  • 컬럼을 추가하면서 초기값을 함께 지정할 수 있습니다.
  • cmd와 views 매개변수를 지정하여 명령(BindCommand)의 뷰에 컬럼을 매핑할 수 있습니다.
  • views매개변수는 기본적으로 전체 뷰가 지정되어 있습니다. (기본값 '$all')

컬럼 추가 예제

js
const bm = new BindModel();

// 컬럼 추가
bm.addColumnValue('gender', 'Man');

console.log(bm.columns['gender'].value);                   // Out: 'Man'
console.log(bm.first.columns['gender'].value);             // Out: 'Man'
console.log(bm._tables['first'].columns['gender'].value);  // Out: 'Man'
  • gender 컬럼이 _baseTable 에 등록되고, columns 속성과 first 속성으로 확인할 수 있습니다.

컬럼 추가 및 모든 뷰에 매핑 예제

js
// 명령 등록
bm.addCommand('cmd1');

// 컬럼 추가 및 명령에 매핑
bm.addColumnValue('username', 'Jane', 'cmd1');

console.log(bm.cmd['cmd1'].valid.columns['username'].value);  // Out: 'Jane'
console.log(bm.cmd['cmd1'].bind.columns['username'].value);   // Out: 'Jane'
console.log(bm.cmd['cmd1'].output.columns['username'].value); // Out: 'Jane'
console.log(bm.cmd['cmd1'].misc.columns['username'].value);   // Out: 'Jane'
  •  username 컬럼을 모든 뷰(valid, bind, output, misc)에 참조값이 등록됩니다.

컬럼 추가 및 특정 뷰에 매핑 예제

js
// 컬럼 추가 및 명령에 매핑
bm.addColumnValue('email', 'abc@gmail.com', 'cmd1', 'valid');
bm.addColumnValue('phone', '010-1234', 'cmd1', ['bind','output']);

console.log(bm.cmd['cmd1'].valid.cols['email'].value);  // Out: 'abc@gmail.com'
console.log(bm.cmd['cmd1'].bind.cols['phone'].value);   // Out: '010-1234'
console.log(bm.cmd['cmd1'].output.cols['phone'].value); // Out: '010-1234'
  • email 컬럼을 valid 뷰에만 매핑되고,
  • phone 컬럼은 bind와 output 뷰에 매핑됩니다.

사용자 정의 출력 뷰에 추가 예제

js
// 출력 뷰 및 컬럼 추가
bm.command['cmd1'].newOutput('out2');
bm.addColumnValue('address', 'USA', 'cmd1', 'out2');

console.log(bm.command['cmd1'].out2.columns['address'].value); // Out: 'USA'
  • 추가된 출력 뷰(out2)에 address 컬럼이 매핑됩니다.

setService()#

서비스 객체를 주입하여 BindModel 객체를 구성하는 메서드입니다.

ts
declare function setService(
	service: ServiceType, 
	chkPass?: boolean
) : void;
  • service: BindModel과 주입할 서비스 객체
  • chkPass(선택) : 타입 검사를 생략할지 여부 (기본값 false)
    •  true로 설정하면 타입 검사를 생략하고 서비스를 등록할 수 있습니다.

setService() 메서드는 서비스 객체를 주입하여 BindModel 객체를 구성합니다.

Tip: 비즈니스 로직을 분리하여 코드의 재사용성과 유지보수성을 높이는데 활용할 수 있습니다.

서비스객체 타입

ts
// 공통 컬럼 속성 타입 (items)
type KeyType = 'none' | 'value' | 'text' | 'html' | 'prop' | 'attr' | 'css';
type SelectorType = { key: string, type: KeyType };
type RegExpType = {reg: RegExp, msg: string, return?: boolean};
type FuncType = (value: any) => boolean;
type ConstraintType = RegExpType | FuncType;
type ColumnType = {
    selector?: SelectorType,
    getter?: () => any,
    setter?: (val: any) => any,
    getFilter?: () => any,
    setFilter?: (val: any) => any,
    default?: string | number | boolean | null,
    value?: any,
    alias?: string,
    caption?: string,
    constraints?: ConstraintType[] | ConstraintType,
    required?: boolean | false,
    columnName?: string
};
type ItemType = ColumnType | string | number | boolean;

// 명령 타입
type CmdPropType = {
    outputOption?: 0 | 1 | 2 | 3,  // 데이터 출력 옵션
    views?: string[],              // 추가할 뷰(MetaView) 목록
    config?: object,               // axios 설정 객체
    url?: string,                  // 서버 요청 URL
    // 명령 콜백 함수
    cbBegin?: (model: BindModel, cmd: BindCommand) => void,
    cbValid?: (view: MetaView, cmd: BindCommand, model: BindModel) => boolean,
    cbBind?: (view: MetaView, cmd: BindCommand, cfg: object) => void,
    cbResult?: (data: object, cmd: BindCommand, res: object) => object,
    cbOutput?: (views: MetaViewCollection, cmd: BindCommand, res: object) => void,
    cbEnd?: (status: number, cmd: BindCommand, res: object) => void,
    // 명령 이벤트
    onExecute?: (model: BindModel, cmd: BindCommand) => void,
    onExecuted?: (model: BindModel, cmd: BindCommand) => void,
};
type CommandType = { [key: string]: CmdPropType };

// 매핑 타입
type CommandName = '$all' | string;  // 명령 이름 ('$all'은 모든 명령을 의미)
type ViewName = 'valid' | 'bind' | 'output' | '$all' | string; // 뷰 이름
type MappingType = {
    [key: ColumnName]: {
        [key: CommandName]: ViewName | ViewName[] // 명령 이름과 매핑된 뷰 목록
    }
};

// 서비스 타입
type ServiceType = {
    // 기본 서버 설정
    url?: string,
    baseConfig?: axiosConfig,  
    // 추가할 테이블
    tables?: string[],
    // 기본 콜백 함수
    cbBaseBegin?: (model: BindModel, cmd: BindCommand) => void;
    cbBaseValid?: (view: MetaView, cmd: BindCommand, model: BindModel) => boolean,
    cbBaseBind?: (view: MetaView, cmd: BindCommand, cfg: object) => void,
    cbBaseResult?: (data: object, cmd: BindCommand, res: object) => object,
    cbBaseOutput?: (outs: MetaViewCollection, cmd: BindCommand, res: object) => void,
    cbBaseEnd?: (status: number, cmd: BindCommand, res: object) => void,
    preRegister?: (bindModel) => void,
    preCheck?: (bindModel) => boolean,
    preReady?: (bindModel) => void,
    // 공통 이벤트
    onExecute?: (bm: BindModel, bc: BindCommand) => void,
    onExecuted?: (bm: BindModel, bc: BindCommand) => void,
	// 공통 속성 타입 (items)
	items?: { [key: string]: ItemType },
	// 명령 타입
	command?: CommandType,
	// 매핑 타입
	mapping?: MappingType,
	// 함수 타입
	fn?: { [key: string]: Function }
};

서비스 객체 주입 예제

js
const bm = new BindModel();

const svc = { tables: ['second'] };

// 서비스 객체 주입
bm.setService(svc);

console.log(bm.second); // [Object MetaTable "second"]

참조 : 서비스 객체 주입


setMapping()#

지정된 명령(BindCommand)의 뷰(MetaView)에 컬럼을 매핑하는 메서드입니다.

ts
type CommandName = '$all' | string;  // 명령 이름 ('$all'은 모든 명령을 의미)
type ViewName = 'valid' | 'bind' | 'output' | '$all' | string; // 뷰 이름
type MappingType = {
    [key: ColumnName]: {
        [key: CommandName]: ViewName | ViewName[] // 명령 이름과 매핑된 뷰 목록
    }
};

declare function setMapping(
    mapping: MappingType | PropertyCollection, 
    baseTable?: string | MetaTable
): void;
  • MappingType: 매핑 설정 객체
    • ColumnName: 매핑할 컬럼 이름
      • CommandName: 매핑할 명령 이름
        • ViewName: 매핑할 뷰 이름 ('$all', 'valid', 'bind', 'output', '추가한 뷰이름')
  • PropertyCollection: 키(컬럼명)와 값(명령별 뷰 설정)의 컬렉션
  • baseTable(선택): 매핑 작업을 수행할 기본 테이블 (기본값 _baseTable)

setMapping() 메서드는 컬럼을 지정한 명령의 뷰에 매핑하며, 이는 여러 컬럼의 매핑 작업을 일괄적으로 처리할 수 있습니다.

명령과 연계된 매핑 예제

js
const bm = new BindModel();

bm.addCommand('cmd1');
bm.addCommand('cmd2');

bm.setMapping({
    'username': { cmd1: 'valid'},
    'password': { cmd1: 'valid', cmd2: ['valid', 'bind'] }
});

console.log(bm.command['cmd1'].valid.cols['username']); // [Object HTMLColumn]
console.log(bm.command['cmd1'].valid.cols['password']); // [Object HTMLColumn]
console.log(bm.command['cmd2'].valid.cols['password']); // [Object HTMLColumn]
console.log(bm.command['cmd2'].bind.cols['password']);  // [Object HTMLColumn]
  • cmd1 명령의 valid 뷰에 username과 password 컬럼을 매핑합니다.
  • cmd2 명령에서는 password 컬럼을 valid와 bind 뷰에 매핑합니다.

두번째 테이블과 명령 매핑

js
const bm = new BindModel();

bm.addTable('second');

bm.addCommand('read1');
bm.addCommand('read2');

bm.setMapping({
    aa: { $all: 'valid' },
    bb: { $all: 'bind' },
    'second.cc': { $all: 'output' }
});

console.log(bm.first.columns.count);  // 2
console.log(bm.second.columns.count); // 1
console.log(bm.command['read1'].valid.cols['aa']);  // [Object HTMLColumn]
console.log(bm.command['read1'].bind.cols['bb']);   // [Object HTMLColumn]
console.log(bm.command['read1'].output.cols['cc']); // [Object HTMLColumn]

console.log(bm.command['read2'].valid.cols['aa']);  // [Object HTMLColumn]
console.log(bm.command['read2'].bind.cols['bb']);   // [Object HTMLColumn]
console.log(bm.command['read2'].output.cols['cc']); // [Object HTMLColumn]
  • setMapping 메서드를 사용하여 두 개의 명령과 두 개의 테이블에 컬럼을 매핑합니다.
  • 기본 테이블의 aa와 bb 컬럼은 각각 valid와 bind 뷰에 매핑됩니다.
  • 두 번째 테이블의 cc 컬럼은 output 뷰에 매핑됩니다.

init()#

BindModel 객체를 초기화하는 메서드입니다.

ts
declare function init(): void;

init() 메서드는 BindModel 객체를 초기화하는 데 사용됩니다. 초기화 과정에서 preRegister, preCheck, preReady 의 콜백 함수가 순차적으로 호출됩니다.

  • preRegister 함수를 통해 필요한 명령 또는 컬럼 등을 추가하거나 설정합니다.
  • preCheck 함수를 통해 초기화 전에 데이터와 실행환경의 유효성을 확인합니다.
  • preReady 함수를 호출하여 초기화 완료 후의 후속 작업을 처리합니다.

Tip : 초기화 과정은 필요에 따라 생략할 수 있으며, 서비스 객체를 주입하여 자동 검사할 때 사용됩니다.

js
const bm = new BindModel();

bm.preRegister = function(model) {
    console.log('Registering the model...');
};
bm.preCheck = function(model) {
    console.log('Checking the model...');
    return true;
};
bm.preReady = function(model) {
    console.log('Model is ready...');
};

bm.init();
// Out:
// 'Registering the model...'
// 'Checking the model...'
// 'Model is ready...'
  • preRegister, preCheck, preReady 함수로 초기화 과정의 각 단계를 설정합니다.

Tip : init()은 서비스 객체를 주입하여 자동화를 수행할 때 유용합니다.


checkSelector()#

selector 속성을 검사하여 유효하지 않은 항목을 반환하는 메서드입니다.

ts
type SelectorType = { key: string, type: string };

declare function checkSelector(
	collection?: ViewColumnCollection | TableColumnCollection,
	viewLog?: boolean
): SelectorType[];
  • collection(선택): 유효성을 검사할 컬렉션 객체 (기본값 items)
  • viewLog(선택): 검사 결과를 로그로 출력할지 여부 (기본값 false)
  • 반환값: 유효성 검사를 통과하지 못한 항목의 목록을 반환합니다.

checkSelector() 메서드는 selector 속성의 유효성을 검사하여 올바르게 설정되지 않은 항목을 식별하는 데 사용됩니다.

  • 기본 검사 대상으로 items 컬렉션을 검사합니다.
  • selector 속성이 존재할 경우 key에 대한 type이 유효한지 검사합니다.
  • 사용자가 지정한 컬렉션(예: columns)의 유효성을 검사할 수 있습니다.

참조 : HTMLColum 클래스 selector 속성

유효하지 않은 항목 확인 예제

js
const bm = new BindModel();

// 아이템에 selector 객체 추가
bm.items.add('username', { selector: { key: 'input#username', type: 'value' }})

// 검사
const failList = bm.checkSelector();

console.log(failList); // { key: 'input#username', type: 'value' }
  • items에 selector 속성이 포함된 username 의 유효성을 검사합니다.

Tip: preCheck 콜백 함수를 사용하여 DOM 검사를 수행할 수 있습니다.


getSelector()#

대상 컬렉션에 설정된 selector 객체를 반환하는 메서드입니다.

ts
type SelectorType = { key: string, type: string };

declare function getSelector(collection?: PropertyCollection): SelectorType[];
  • collection(선택): selector 정보를 가져올 PropertyCollection 객체 (기본값 items)
  • 반환값: SelectorType 객체 배열을 반환합니다.

getSelector() 메서드는 지정된 컬렉션에 설정된 selector 객체를 배열로 반환합니다.

js
const bm = new BindModel();

// 아이템 추가
bm.items.add('u_name', { selector: { key: 'input#u_name', type: 'value' }})
bm.items.add('passwd', { selector: { key: 'input#passwd', type: 'value' }})

// 조회
const list = bm.getSelector();

console.log(list); 
// Out:
// [ 
//   { selector: { key: 'input#u_name', type: 'value' }},
//   { selector: { key: 'input#passwd', type: 'value' }} 
// ]
  • getSelector() 메서드를 호출하여 설정된 모든 selector 객체를 배열 형태로 반환 받습니다.

이벤트#

onExecute#

명령(BindCommand)이 실행되기 전에 호출되는 전역 이벤트 속성입니다.

ts
type onExecute = (model: BindModel, cmd: BindCommand) => void;
  • model: 실행 중인 BindModel 객체
  • cmd: 실행 중인 BindCommand 객체

onExecute는 명령이 실행되기 전에 호출되는 전역 이벤트로, 모든 명령 실행 시 항상 작동합니다.

Tip : 이벤트 속성에 콜백함수를 설정하면, 기존 이벤트는 그대로 유지되며 새 이벤트가 추가됩니다.

js
const bm = new BindModel();

// 이벤트 등록
bm.onExecute = function(model, cmd) {
    console.log('Execute start...');
};

// 명령 추가 및 실행
bm.addCommand('cmd1');
bm.command['cmd1'].execute();
  • 모든 명령(BindCommand) 실행 전에 콘솔에 'Execute start...' 메시지가 출력됩니다.

onExecuted#

명령(BindCommand)이 실행된 후 호출되는 전역 이벤트 속성입니다.

ts
type onExecute = (model: BindModel, cmd: BindCommand) => void;
  • model: 실행 중인 BindModel 객체
  • cmd: 실행 중인 BindCommand 객체

onExecuted는 명령이 성공적으로 실행된 후 호출되는 전역 이벤트로, 모든 명령 실행시 항상 작동합니다.

Tip : 이벤트 속성에 콜백함수를 설정하면, 기존 이벤트는 그대로 유지되며 새 이벤트가 추가됩니다.

js
const bm = new BindModel();

// 이벤트 등록
bm.onExecuted = function(model, cmd) {
    console.log('Execute End...');
};

// 명령 추가 및 실행
bm.addCommand('cmd1');
bm.command['cmd1'].execute();
  • 모든 명령 실행 후에 콘솔에 'Execute End...' 메시지가 출력됩니다.

검색어를 입력해 보세요.