redoc/lib/components/base.js

155 lines
4.7 KiB
JavaScript
Raw Normal View History

'use strict';
2015-11-29 13:47:42 +03:00
import {Component, View, OnInit, CORE_DIRECTIVES, ChangeDetectionStrategy} from 'angular2/angular2';
2015-10-27 20:44:08 +03:00
import SchemaManager from '../utils/SchemaManager';
import JsonPointer from '../utils/JsonPointer';
import {MarkedPipe, JsonPointerEscapePipe} from '../utils/pipes';
// common inputs for all components
let commonInputs = ['pointer']; // json pointer to the schema chunk
// internal helper function
function safeConcat(a, b) {
let res = a && a.slice() || [];
b = (b == null) ? [] : b;
return res.concat(b);
}
/**
* Class decorator
* Simplifies setup of component metainfo
* All options are options from either Component or View angular2 decorator
* For detailed info look angular2 doc
* @param {Object} options - component options
* @param {string[]} options.inputs - component inputs
* @param {*[]} options.directives - directives used by component
* (except CORE_DIRECTIVES)
* @param {*[]} options.pipes - pipes used by component
2015-10-17 21:56:24 +03:00
* @param {*[]} options.providers - component providers
* @param {string} options.templateUrl - path to component template
* @param {string} options.template - component template html
* @param {string} options.styles - component css styles
*/
export function RedocComponent(options) {
let inputs = safeConcat(options.inputs, commonInputs);
let directives = safeConcat(options.directives, CORE_DIRECTIVES);
let pipes = safeConcat(options.pipes, [JsonPointerEscapePipe, MarkedPipe]);
return function decorator(target) {
let componentDecorator = Component({
selector: options.selector,
inputs: inputs,
2015-10-15 21:35:05 +03:00
outputs: options.outputs,
lifecycle: [OnInit],
2015-11-29 13:47:42 +03:00
providers: options.providers,
changeDetection: options.changeDetection || ChangeDetectionStrategy.Detached
});
let viewDecorator = View({
templateUrl: options.templateUrl,
template: options.template,
styles: options.styles,
directives: directives,
pipes: pipes
});
return componentDecorator(viewDecorator(target) || target) || target;
};
}
/**
* Generic Component
* @class
*/
export class BaseComponent {
constructor(schemaMgr) {
this.schemaMgr = schemaMgr;
this.schema = schemaMgr.schema;
this.componentSchema = null;
}
/**
* onInit method is run by angular2 after all component inputs are resolved
*/
onInit() {
this.componentSchema = this.schemaMgr.byPointer(this.pointer || '');
this.prepareModel();
2015-10-17 21:12:46 +03:00
this.init();
}
2015-10-21 17:22:22 +03:00
/**
* simple in-place schema dereferencing. Schema is already bundled so no need in global dereferencing.
* TODO: doesn't support circular references
*/
2015-11-28 01:44:35 +03:00
dereference(schema = Object.assign({}, this.componentSchema)) {
//schema = Object.assign({}, schema);
2015-10-21 17:22:22 +03:00
if (schema && schema.$ref) {
let resolved = this.schemaMgr.byPointer(schema.$ref);
let baseName = JsonPointer.baseName(schema.$ref);
// if resolved schema doesn't have title use name from ref
resolved = Object.assign({}, resolved);
2015-10-21 17:22:22 +03:00
resolved.title = resolved.title || baseName;
resolved._pointer = schema.$ref;
2015-10-21 17:22:22 +03:00
Object.assign(schema, resolved);
delete schema.$ref;
}
Object.keys(schema).forEach((key) => {
let value = schema[key];
if (value && typeof value === 'object') {
this.dereference(value);
}
});
2015-11-28 01:44:35 +03:00
this.componentSchema = schema;
2015-10-21 17:22:22 +03:00
}
2015-11-25 02:51:54 +03:00
joinAllOf(schema = this.componentSchema) {
var self = this;
function merge(into, schemas) {
if (into.required || into.properties) {
let errMessage = `Can\'t merge allOf: properties or required fields are specified on the same level as allOf
${into}`;
throw new Error(errMessage);
2015-11-25 02:51:54 +03:00
}
into.required = [];
into.properties = {};
for (let subSchema of schemas) {
// TODO: add support for merge array schemas
2015-11-25 02:51:54 +03:00
if (typeof subSchema !== 'object' || subSchema.type !== 'object') {
let errMessage = `Can\'t merge allOf: only subschemas with type: object can be merged
${subSchema}`;
throw new Error(errMessage);
2015-11-25 02:51:54 +03:00
}
self.joinAllOf(subSchema);
// TODO: add check if can be merged correctly (no different properties with the same name)
2015-11-25 02:51:54 +03:00
if (subSchema.properties) {
Object.assign(into.properties, subSchema.properties);
}
if (subSchema.required) {
into.required.push(...subSchema.required);
}
}
into.type = 'object';
into.allOf = null;
}
if (schema.allOf) {
merge(schema, schema.allOf);
}
}
/**
* Used to prepare model based on component schema
* @abstract
*/
prepareModel() {}
2015-10-17 21:12:46 +03:00
/**
* Used to initialize component. Run after prepareModel
* @abstract
*/
init() {}
}
BaseComponent.parameters = [[SchemaManager]];