@zenstackhq/language 3.5.5 → 3.6.0

package/dist/factory.mjs

@@ -0,0 +1,778 @@
+import { A as InternalAttribute, C as EnumField, F as Model, G as ReferenceExpr, I as ModelImport, J as ThisExpr, L as NullExpr, N as MemberAccessExpr, Q as UnsupportedFieldType, R as NumberLiteral, S as Enum, T as FieldInitializer, W as ReferenceArg, Z as UnaryExpr, _ as DataFieldAttribute, a as AttributeArg, b as DataModelAttribute, c as BinaryExpr, g as DataField, i as Attribute, j as InvocationExpr, l as BooleanLiteral, n as Argument, o as AttributeParam, q as StringLiteral, r as ArrayExpr, s as AttributeParamType, v as DataFieldType, y as DataModel, z as ObjectExpr } from "./ast-DEfhnj8j.mjs";
+import "./ast.mjs";
+//#region src/factory/ast-factory.ts
+var AstFactory = class AstFactory {
+	node = {};
+	constructor({ type, node }) {
+		this.node.$type = type;
+		if (node) this.update(node);
+	}
+	setContainer(container) {
+		this.node.$container = container;
+		return this;
+	}
+	get(params) {
+		if (params) this.update(params);
+		return this.node;
+	}
+	update(nodeArg) {
+		Object.keys(nodeArg).forEach((key) => {
+			const child = nodeArg[key];
+			if (child instanceof AstFactory) this.node[key] = child.get({ $container: this.node });
+			else if (Array.isArray(child)) this.node[key] = child.map((item) => item instanceof AstFactory ? item.get({ $container: this.node }) : item);
+			else this.node[key] = child;
+		});
+		return this.node;
+	}
+};
+//#endregion
+//#region src/factory/primitives.ts
+var ThisExprFactory = class extends AstFactory {
+	constructor() {
+		super({
+			type: ThisExpr,
+			node: { value: "this" }
+		});
+	}
+};
+var NullExprFactory = class extends AstFactory {
+	constructor() {
+		super({
+			type: NullExpr,
+			node: { value: "null" }
+		});
+	}
+};
+var NumberLiteralFactory = class extends AstFactory {
+	value;
+	constructor() {
+		super({ type: NumberLiteral });
+	}
+	setValue(value) {
+		this.value = value;
+		this.update({ value: this.value.toString() });
+		return this;
+	}
+};
+var StringLiteralFactory = class extends AstFactory {
+	value;
+	constructor() {
+		super({ type: StringLiteral });
+	}
+	setValue(value) {
+		this.value = value;
+		this.update({ value: this.value });
+		return this;
+	}
+};
+var BooleanLiteralFactory = class extends AstFactory {
+	value;
+	constructor() {
+		super({ type: BooleanLiteral });
+	}
+	setValue(value) {
+		this.value = value;
+		this.update({ value: this.value });
+		return this;
+	}
+};
+//#endregion
+//#region src/factory/expression.ts
+const ExpressionBuilder = () => ({
+	get ArrayExpr() {
+		return new ArrayExprFactory();
+	},
+	get BinaryExpr() {
+		return new BinaryExprFactory();
+	},
+	get BooleanLiteral() {
+		return new BooleanLiteralFactory();
+	},
+	get InvocationExpr() {
+		return new InvocationExprFactory();
+	},
+	get MemberAccessExpr() {
+		return new MemberAccessExprFactory();
+	},
+	get NullExpr() {
+		return new NullExprFactory();
+	},
+	get NumberLiteral() {
+		return new NumberLiteralFactory();
+	},
+	get ObjectExpr() {
+		return new ObjectExprFactory();
+	},
+	get ReferenceExpr() {
+		return new ReferenceExprFactory();
+	},
+	get StringLiteral() {
+		return new StringLiteralFactory();
+	},
+	get ThisExpr() {
+		return new ThisExprFactory();
+	},
+	get UnaryExpr() {
+		return new UnaryExprFactory();
+	}
+});
+var UnaryExprFactory = class extends AstFactory {
+	operand;
+	constructor() {
+		super({
+			type: UnaryExpr,
+			node: { operator: "!" }
+		});
+	}
+	setOperand(builder) {
+		this.operand = builder(ExpressionBuilder());
+		this.update({ operand: this.operand });
+		return this;
+	}
+};
+var ReferenceExprFactory = class extends AstFactory {
+	target;
+	args = [];
+	constructor() {
+		super({
+			type: ReferenceExpr,
+			node: { args: [] }
+		});
+	}
+	setTarget(target) {
+		this.target = {
+			$refText: target.name,
+			ref: target
+		};
+		this.update({ target: this.target });
+		return this;
+	}
+	addArg(builder, name) {
+		const arg = new ReferenceArgFactory().setValue(builder);
+		if (name) arg.setName(name);
+		this.args.push(arg);
+		this.update({ args: this.args });
+		return this;
+	}
+};
+var ReferenceArgFactory = class extends AstFactory {
+	name;
+	value;
+	constructor() {
+		super({ type: ReferenceArg });
+	}
+	setName(name) {
+		this.name = name;
+		this.update({ name: this.name });
+		return this;
+	}
+	setValue(builder) {
+		this.value = builder(ExpressionBuilder());
+		this.update({ value: this.value });
+		return this;
+	}
+};
+var MemberAccessExprFactory = class extends AstFactory {
+	member;
+	operand;
+	constructor() {
+		super({ type: MemberAccessExpr });
+	}
+	setMember(target) {
+		this.member = target;
+		this.update({ member: this.member });
+		return this;
+	}
+	setOperand(builder) {
+		this.operand = builder(ExpressionBuilder());
+		this.update({ operand: this.operand });
+		return this;
+	}
+};
+var ObjectExprFactory = class extends AstFactory {
+	fields = [];
+	constructor() {
+		super({
+			type: ObjectExpr,
+			node: { fields: [] }
+		});
+	}
+	addField(builder) {
+		this.fields.push(builder(new FieldInitializerFactory()));
+		this.update({ fields: this.fields });
+		return this;
+	}
+};
+var FieldInitializerFactory = class extends AstFactory {
+	name;
+	value;
+	constructor() {
+		super({ type: FieldInitializer });
+	}
+	setName(name) {
+		this.name = name;
+		this.update({ name: this.name });
+		return this;
+	}
+	setValue(builder) {
+		this.value = builder(ExpressionBuilder());
+		this.update({ value: this.value });
+		return this;
+	}
+};
+var InvocationExprFactory = class extends AstFactory {
+	args = [];
+	function;
+	constructor() {
+		super({
+			type: InvocationExpr,
+			node: { args: [] }
+		});
+	}
+	addArg(builder) {
+		this.args.push(builder(new ArgumentFactory()));
+		this.update({ args: this.args });
+		return this;
+	}
+	setFunction(value) {
+		this.function = {
+			$refText: value.name,
+			ref: value
+		};
+		this.update({ function: this.function });
+		return this;
+	}
+};
+var ArgumentFactory = class extends AstFactory {
+	value;
+	constructor() {
+		super({ type: Argument });
+	}
+	setValue(builder) {
+		this.value = builder(ExpressionBuilder());
+		this.update({ value: this.value });
+		return this;
+	}
+};
+var ArrayExprFactory = class extends AstFactory {
+	items = [];
+	constructor() {
+		super({
+			type: ArrayExpr,
+			node: { items: [] }
+		});
+	}
+	addItem(builder) {
+		this.items.push(builder(ExpressionBuilder()));
+		this.update({ items: this.items });
+		return this;
+	}
+};
+var BinaryExprFactory = class extends AstFactory {
+	operator;
+	right;
+	left;
+	constructor() {
+		super({ type: BinaryExpr });
+	}
+	setOperator(operator) {
+		this.operator = operator;
+		this.update({ operator: this.operator });
+		return this;
+	}
+	setRight(builder) {
+		this.right = builder(ExpressionBuilder());
+		this.update({ right: this.right });
+		return this;
+	}
+	setLeft(builder) {
+		this.left = builder(ExpressionBuilder());
+		this.update({ left: this.left });
+		return this;
+	}
+};
+//#endregion
+//#region src/factory/attribute.ts
+var DataFieldAttributeFactory = class extends AstFactory {
+	args = [];
+	decl;
+	constructor() {
+		super({
+			type: DataFieldAttribute,
+			node: { args: [] }
+		});
+	}
+	setDecl(decl) {
+		if (!decl) throw new Error("Attribute declaration is required");
+		this.decl = {
+			$refText: decl.name,
+			ref: decl
+		};
+		this.update({ decl: this.decl });
+		return this;
+	}
+	addArg(builder, name) {
+		const factory = new AttributeArgFactory().setValue(builder);
+		if (name) factory.setName(name);
+		this.args.push(factory);
+		this.update({ args: this.args });
+		return this;
+	}
+};
+var DataModelAttributeFactory = class extends AstFactory {
+	args = [];
+	decl;
+	constructor() {
+		super({
+			type: DataModelAttribute,
+			node: { args: [] }
+		});
+	}
+	setDecl(decl) {
+		if (!decl) throw new Error("Attribute declaration is required");
+		this.decl = {
+			$refText: decl.name,
+			ref: decl
+		};
+		this.update({ decl: this.decl });
+		return this;
+	}
+	addArg(builder, name) {
+		const factory = new AttributeArgFactory().setValue(builder);
+		if (name) factory.setName(name);
+		this.args.push(factory);
+		this.update({ args: this.args });
+		return this;
+	}
+};
+var AttributeArgFactory = class extends AstFactory {
+	name = "";
+	value;
+	constructor() {
+		super({ type: AttributeArg });
+	}
+	setName(name) {
+		this.name = name;
+		this.update({ name: this.name });
+		return this;
+	}
+	setValue(builder) {
+		this.value = builder(ExpressionBuilder());
+		this.update({ value: this.value });
+		return this;
+	}
+};
+var InternalAttributeFactory = class extends AstFactory {
+	decl;
+	args = [];
+	constructor() {
+		super({
+			type: InternalAttribute,
+			node: { args: [] }
+		});
+	}
+	setDecl(decl) {
+		this.decl = {
+			$refText: decl.name,
+			ref: decl
+		};
+		this.update({ decl: this.decl });
+		return this;
+	}
+	addArg(builder, name) {
+		const factory = new AttributeArgFactory().setValue(builder);
+		if (name) factory.setName(name);
+		this.args.push(factory);
+		this.update({ args: this.args });
+		return this;
+	}
+};
+var AttributeParamFactory = class extends AstFactory {
+	attributes = [];
+	comments = [];
+	default;
+	name;
+	type;
+	constructor() {
+		super({
+			type: AttributeParam,
+			node: {
+				comments: [],
+				attributes: []
+			}
+		});
+	}
+	addAttribute(builder) {
+		this.attributes.push(builder(new InternalAttributeFactory()));
+		this.update({ attributes: this.attributes });
+		return this;
+	}
+	setComments(comments) {
+		this.comments = comments;
+		this.update({ comments: this.comments });
+		return this;
+	}
+	setDefault(defaultValue) {
+		this.default = defaultValue;
+		this.update({ default: this.default });
+		return this;
+	}
+	setName(name) {
+		this.name = name;
+		this.update({ name: this.name });
+		return this;
+	}
+	setType(builder) {
+		this.type = builder(new AttributeParamTypeFactory());
+		this.update({ type: this.type });
+		return this;
+	}
+};
+var AttributeParamTypeFactory = class extends AstFactory {
+	array;
+	optional;
+	reference;
+	type;
+	constructor() {
+		super({ type: AttributeParamType });
+	}
+	setArray(array) {
+		this.array = array;
+		this.update({ array: this.array });
+		return this;
+	}
+	setOptional(optional) {
+		this.optional = optional;
+		this.update({ optional: this.optional });
+		return this;
+	}
+	setReference(reference) {
+		this.reference = {
+			$refText: reference.name,
+			ref: reference
+		};
+		this.update({ reference: this.reference });
+		return this;
+	}
+	setType(type) {
+		this.type = type;
+		this.update({ type: this.type });
+		return this;
+	}
+};
+var AttributeFactory = class extends AstFactory {
+	name;
+	comments = [];
+	attributes = [];
+	params = [];
+	constructor() {
+		super({
+			type: Attribute,
+			node: {
+				comments: [],
+				attributes: [],
+				params: []
+			}
+		});
+	}
+	setName(name) {
+		this.name = name;
+		this.update({ name: this.name });
+		return this;
+	}
+	setComments(comments) {
+		this.comments = comments;
+		this.update({ comments: this.comments });
+		return this;
+	}
+	addAttribute(builder) {
+		this.attributes.push(builder(new InternalAttributeFactory()));
+		this.update({ attributes: this.attributes });
+		return this;
+	}
+	addParam(builder) {
+		this.params.push(builder(new AttributeParamFactory()));
+		this.update({ params: this.params });
+		return this;
+	}
+};
+//#endregion
+//#region src/factory/declaration.ts
+const DeclarationBuilder = () => ({
+	get Attribute() {
+		return new AttributeFactory();
+	},
+	get DataModel() {
+		return new DataModelFactory();
+	},
+	get DataSource() {
+		throw new Error("DataSource is not implemented");
+	},
+	get Enum() {
+		return new EnumFactory();
+	},
+	get FunctionDecl() {
+		throw new Error("FunctionDecl is not implemented");
+	},
+	get GeneratorDecl() {
+		throw new Error("GeneratorDecl is not implemented");
+	},
+	get Plugin() {
+		throw new Error("Plugin is not implemented");
+	},
+	get Procedure() {
+		throw new Error("Procedure is not implemented");
+	},
+	get TypeDef() {
+		throw new Error("TypeDef is not implemented");
+	}
+});
+var DataModelFactory = class extends AstFactory {
+	attributes = [];
+	baseModel;
+	comments = [];
+	fields = [];
+	isView;
+	mixins = [];
+	name;
+	constructor() {
+		super({
+			type: DataModel,
+			node: {
+				attributes: [],
+				comments: [],
+				fields: [],
+				mixins: []
+			}
+		});
+	}
+	addAttribute(builder) {
+		this.attributes.push(builder(new DataModelAttributeFactory()).setContainer(this.node));
+		this.update({ attributes: this.attributes });
+		return this;
+	}
+	setBaseModel(model) {
+		this.baseModel = model;
+		this.update({ baseModel: this.baseModel });
+		return this;
+	}
+	setComments(comments) {
+		this.comments = comments;
+		this.update({ comments: this.comments });
+		return this;
+	}
+	addComment(comment) {
+		this.comments.push(comment);
+		this.update({ comments: this.comments });
+		return this;
+	}
+	addField(builder) {
+		this.fields.push(builder(new DataFieldFactory()).setContainer(this.node));
+		this.update({ fields: this.fields });
+		return this;
+	}
+	setIsView(isView) {
+		this.isView = isView;
+		this.update({ isView: this.isView });
+		return this;
+	}
+	addMixin(mixin) {
+		this.mixins.push(mixin);
+		this.update({ mixins: this.mixins });
+		return this;
+	}
+	setName(name) {
+		this.name = name;
+		this.update({ name: this.name });
+		return this;
+	}
+};
+var DataFieldFactory = class extends AstFactory {
+	attributes = [];
+	comments = [];
+	name;
+	type;
+	constructor() {
+		super({
+			type: DataField,
+			node: {
+				attributes: [],
+				comments: []
+			}
+		});
+	}
+	addAttribute(builder) {
+		if (builder instanceof DataFieldAttributeFactory) {
+			builder.setContainer(this.node);
+			this.attributes.push(builder);
+		} else {
+			const attr = builder(new DataFieldAttributeFactory());
+			attr.setContainer(this.node);
+			this.attributes.push(attr);
+		}
+		this.update({ attributes: this.attributes });
+		return this;
+	}
+	setComments(comments) {
+		this.comments = comments;
+		this.update({ comments: this.comments });
+		return this;
+	}
+	setName(name) {
+		this.name = name;
+		this.update({ name: this.name });
+		return this;
+	}
+	setType(builder) {
+		this.type = builder(new DataFieldTypeFactory()).setContainer(this.node);
+		this.update({ type: this.type });
+		return this;
+	}
+};
+var DataFieldTypeFactory = class extends AstFactory {
+	array;
+	optional;
+	reference;
+	type;
+	unsupported;
+	constructor() {
+		super({ type: DataFieldType });
+	}
+	setArray(array) {
+		this.array = array;
+		this.update({ array: this.array });
+		return this;
+	}
+	setOptional(optional) {
+		this.optional = optional;
+		this.update({ optional: this.optional });
+		return this;
+	}
+	setReference(reference) {
+		this.reference = {
+			$refText: reference.name,
+			ref: reference
+		};
+		this.update({ reference: this.reference });
+		return this;
+	}
+	setType(type) {
+		this.type = type;
+		this.update({ type: this.type });
+		return this;
+	}
+	setUnsupported(builder) {
+		this.unsupported = builder(new UnsupportedFieldTypeFactory()).setContainer(this.node);
+		this.update({ unsupported: this.unsupported });
+		return this;
+	}
+};
+var UnsupportedFieldTypeFactory = class extends AstFactory {
+	value;
+	constructor() {
+		super({ type: UnsupportedFieldType });
+	}
+	setValue(builder) {
+		this.value = builder(ExpressionBuilder());
+		this.update({ value: this.value });
+		return this;
+	}
+};
+var ModelFactory = class extends AstFactory {
+	declarations = [];
+	imports = [];
+	constructor() {
+		super({
+			type: Model,
+			node: {
+				declarations: [],
+				imports: []
+			}
+		});
+	}
+	addImport(builder) {
+		this.imports.push(builder(new ModelImportFactory()).setContainer(this.node));
+		this.update({ imports: this.imports });
+		return this;
+	}
+	addDeclaration(builder) {
+		this.declarations.push(builder(DeclarationBuilder()).setContainer(this.node));
+		this.update({ declarations: this.declarations });
+		return this;
+	}
+};
+var ModelImportFactory = class extends AstFactory {
+	path;
+	constructor() {
+		super({ type: ModelImport });
+	}
+	setPath(path) {
+		this.path = path;
+		this.update({ path: this.path });
+		return this;
+	}
+};
+var EnumFactory = class extends AstFactory {
+	name;
+	comments = [];
+	fields = [];
+	attributes = [];
+	constructor() {
+		super({
+			type: Enum,
+			node: {
+				comments: [],
+				fields: [],
+				attributes: []
+			}
+		});
+	}
+	addField(builder) {
+		this.fields.push(builder(new EnumFieldFactory()).setContainer(this.node));
+		this.update({ fields: this.fields });
+		return this;
+	}
+	addAttribute(builder) {
+		this.attributes.push(builder(new DataModelAttributeFactory()).setContainer(this.node));
+		this.update({ attributes: this.attributes });
+		return this;
+	}
+	setName(name) {
+		this.name = name;
+		this.update({ name: this.name });
+		return this;
+	}
+};
+var EnumFieldFactory = class extends AstFactory {
+	name;
+	comments = [];
+	attributes = [];
+	constructor() {
+		super({
+			type: EnumField,
+			node: {
+				comments: [],
+				attributes: []
+			}
+		});
+	}
+	setName(name) {
+		this.name = name;
+		this.update({ name: this.name });
+		return this;
+	}
+	addAttribute(builder) {
+		this.attributes.push(builder(new DataFieldAttributeFactory()).setContainer(this.node));
+		this.update({ attributes: this.attributes });
+		return this;
+	}
+	addComment(comment) {
+		this.comments.push(comment);
+		this.update({ comments: this.comments });
+		return this;
+	}
+};
+//#endregion
+export { ArgumentFactory, ArrayExprFactory, AstFactory, AttributeArgFactory, AttributeFactory, AttributeParamFactory, AttributeParamTypeFactory, BinaryExprFactory, BooleanLiteralFactory, DataFieldAttributeFactory, DataFieldFactory, DataFieldTypeFactory, DataModelAttributeFactory, DataModelFactory, DeclarationBuilder, EnumFactory, EnumFieldFactory, ExpressionBuilder, FieldInitializerFactory, InternalAttributeFactory, InvocationExprFactory, MemberAccessExprFactory, ModelFactory, ModelImportFactory, NullExprFactory, NumberLiteralFactory, ObjectExprFactory, ReferenceArgFactory, ReferenceExprFactory, StringLiteralFactory, ThisExprFactory, UnaryExprFactory, UnsupportedFieldTypeFactory };
+
+//# sourceMappingURL=factory.mjs.map