@yellicode/elements/dist/es5/model-builder.js

The meta model API for Yellicode - an extensible code generator.

var __extends = (this && this.__extends) || (function () {
    var extendStatics = function (d, b) {
        extendStatics = Object.setPrototypeOf ||
            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
        return extendStatics(d, b);
    };
    return function (d, b) {
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
import { ModelDelegateImpl } from './model-delegate';
import { ElementMapImpl } from './element-map';
import * as elements from './interfaces';
import * as classes from './classes';
import { UniqueId } from '@yellicode/core';
// import { ElementFactory } from './element-factory';
// TODO: generate PropertyBuilder, OperationBuilder, MemberedClassifierBuilder and PackageBuilder
// To be supported: interface, class, primitiveType, enumeration, dataType, package
var ElementBuilderBase = /** @class */ (function () {
    function ElementBuilderBase(element, modelDelegate) {
        this.element = element;
        this.modelDelegate = modelDelegate;
        this.elementMap = modelDelegate.elementMap;
    }
    ElementBuilderBase.prototype.addToElementMap = function (element) {
        this.elementMap.addElement(element, null); // the second argument, ElementData, is only needed when deserializing relationships
    };
    return ElementBuilderBase;
}());
export { ElementBuilderBase };
var PropertyBuilder = /** @class */ (function (_super) {
    __extends(PropertyBuilder, _super);
    function PropertyBuilder(element, modelDelegate) {
        return _super.call(this, element, modelDelegate) || this;
    }
    return PropertyBuilder;
}(ElementBuilderBase));
export { PropertyBuilder };
var MemberedClassifierBuilder = /** @class */ (function (_super) {
    __extends(MemberedClassifierBuilder, _super);
    function MemberedClassifierBuilder(element, modelDelegate) {
        return _super.call(this, element, modelDelegate) || this;
    }
    MemberedClassifierBuilder.prototype.addAttribute = function (properties, initFn) {
        var element = new classes.Property(this.modelDelegate, this.element);
        element.name = properties.name;
        element.id = properties.id || UniqueId.create();
        var builder = new PropertyBuilder(element, this.modelDelegate);
        if (initFn)
            initFn(builder);
        this.element.ownedAttributes.push(element);
        this.addToElementMap(element);
        return this;
    };
    return MemberedClassifierBuilder;
}(ElementBuilderBase));
export { MemberedClassifierBuilder };
var InterfaceBuilder = /** @class */ (function (_super) {
    __extends(InterfaceBuilder, _super);
    function InterfaceBuilder(element, modelDelegate) {
        return _super.call(this, element, modelDelegate) || this;
    }
    return InterfaceBuilder;
}(MemberedClassifierBuilder));
export { InterfaceBuilder };
var ClassBuilder = /** @class */ (function (_super) {
    __extends(ClassBuilder, _super);
    function ClassBuilder(element, modelDelegate) {
        return _super.call(this, element, modelDelegate) || this;
    }
    return ClassBuilder;
}(MemberedClassifierBuilder));
export { ClassBuilder };
var PackageBuilder = /** @class */ (function (_super) {
    __extends(PackageBuilder, _super);
    function PackageBuilder(element, modelDelegate) {
        return _super.call(this, element, modelDelegate) || this;
    }
    PackageBuilder.prototype.addClass = function (properties, initFn) {
        var cls = this.createPackageableElement(elements.ElementType.class, properties);
        var builder = new ClassBuilder(cls, this.modelDelegate);
        if (initFn)
            initFn(builder);
        this.element.packagedElements.push(cls);
        this.addToElementMap(cls);
        return this;
    };
    PackageBuilder.prototype.createPackageableElement = function (type, properties) {
        var result;
        switch (type) {
            case elements.ElementType.class:
                result = new classes.Class(this.modelDelegate, this.element);
                break;
            // TODO: interface, class, primitiveType, enumeration, dataType, package    
            default:
                throw "Could not create PackageableElement of type " + elements.ElementType[type] + ".";
        }
        result.name = properties.name;
        result.id = properties.id || UniqueId.create();
        return result;
    };
    return PackageBuilder;
}(ElementBuilderBase));
export { PackageBuilder };
var ModelBuilder = /** @class */ (function (_super) {
    __extends(ModelBuilder, _super);
    function ModelBuilder(model, modelDelegate) {
        var _this = _super.call(this, model, modelDelegate) || this;
        _this.model = model;
        return _this;
    }
    ModelBuilder.create = function (name) {
        var elementMap = new ElementMapImpl();
        // TODO: create primitive types and add to ElementMap?
        var modelDelegate = new ModelDelegateImpl(elementMap);
        var model = new classes.Model(modelDelegate, null /* no owner */);
        model.id = UniqueId.create();
        model.name = name;
        return new ModelBuilder(model, modelDelegate);
    };
    ModelBuilder.prototype.build = function () {
        return this.model;
    };
    return ModelBuilder;
}(PackageBuilder));
export { ModelBuilder };
var veryTinyDemo = ModelBuilder.create('Test model');
veryTinyDemo.addClass({ name: 'My Class' }, function (cls) {
});