@zenstackhq/language 3.3.2 → 3.4.0-beta.1

package/dist/factory.d.ts

@@ -0,0 +1,284 @@
+import { ThisExpr, NullExpr, NumberLiteral, StringLiteral, BooleanLiteral, ArrayExpr, Expression, BinaryExpr, InvocationExpr, Argument, FunctionDecl, MemberAccessExpr, MemberAccessTarget, ObjectExpr, FieldInitializer, RegularID, ReferenceExpr, ReferenceTarget, ReferenceArg, UnaryExpr, Attribute, InternalAttribute, AttributeArg, AttributeParam, AttributeParamType, TypeDeclaration, DataModelAttribute, DataFieldAttribute, DataModel, DataField, DataFieldType, BuiltinType, UnsupportedFieldType, LiteralExpr, TypeDef, Enum, EnumField, RegularIDWithTypeNames, AbstractDeclaration, Model, ModelImport } from './ast.js';
+import { AstNode, Reference } from 'langium';
+
+type ContainerProps<T extends AstNode | undefined> = {
+    $container: T;
+    $containerProperty?: string;
+    $containerIndex?: number;
+};
+type NodeFactoriesFor<N> = {
+    [K in keyof N as {} extends Pick<N, K> ? never : K]: N[K] extends (infer U)[] ? (AstFactory<U extends AstNode ? U : AstNode> | U)[] : AstFactory<N[K] extends AstNode ? N[K] : AstNode> | N[K];
+} & {
+    [K in keyof N as {} extends Pick<N, K> ? K : never]?: N[K] extends (infer U)[] ? (AstFactory<U extends AstNode ? U : AstNode> | U)[] : AstFactory<N[K] extends AstNode ? N[K] : AstNode> | N[K];
+};
+declare abstract class AstFactory<T extends AstNode = AstNode> {
+    node: T;
+    constructor({ type, node }: {
+        type: T['$type'];
+        node?: Partial<T>;
+    });
+    setContainer(container: T['$container']): this;
+    get(params?: ContainerProps<T['$container']>): T;
+    update(nodeArg: Partial<T | NodeFactoriesFor<T>>): T;
+}
+
+declare class ThisExprFactory extends AstFactory<ThisExpr> {
+    constructor();
+}
+declare class NullExprFactory extends AstFactory<NullExpr> {
+    constructor();
+}
+declare class NumberLiteralFactory extends AstFactory<NumberLiteral> {
+    value?: number | string;
+    constructor();
+    setValue(value: number | string): this;
+}
+declare class StringLiteralFactory extends AstFactory<StringLiteral> {
+    value?: string;
+    constructor();
+    setValue(value: string): this;
+}
+declare class BooleanLiteralFactory extends AstFactory<BooleanLiteral> {
+    value?: boolean;
+    constructor();
+    setValue(value: boolean): this;
+}
+
+type ExpressionFactoryMap = ReturnType<typeof ExpressionBuilder>;
+declare const ExpressionBuilder: () => {
+    readonly ArrayExpr: ArrayExprFactory;
+    readonly BinaryExpr: BinaryExprFactory;
+    readonly BooleanLiteral: BooleanLiteralFactory;
+    readonly InvocationExpr: InvocationExprFactory;
+    readonly MemberAccessExpr: MemberAccessExprFactory;
+    readonly NullExpr: NullExprFactory;
+    readonly NumberLiteral: NumberLiteralFactory;
+    readonly ObjectExpr: ObjectExprFactory;
+    readonly ReferenceExpr: ReferenceExprFactory;
+    readonly StringLiteral: StringLiteralFactory;
+    readonly ThisExpr: ThisExprFactory;
+    readonly UnaryExpr: UnaryExprFactory;
+};
+type ExpressionBuilder<T extends Expression = Expression> = Pick<ExpressionFactoryMap, Extract<T['$type'], keyof ExpressionFactoryMap>>;
+declare class UnaryExprFactory extends AstFactory<UnaryExpr> {
+    operand?: AstFactory<Expression>;
+    constructor();
+    setOperand(builder: (a: ExpressionBuilder) => AstFactory<Expression>): this;
+}
+declare class ReferenceExprFactory extends AstFactory<ReferenceExpr> {
+    target?: Reference<ReferenceTarget>;
+    args: ReferenceArgFactory[];
+    constructor();
+    setTarget(target: ReferenceTarget): this;
+    addArg(builder: (a: ExpressionBuilder) => AstFactory<Expression>, name?: string): this;
+}
+declare class ReferenceArgFactory extends AstFactory<ReferenceArg> {
+    name?: string;
+    value?: AstFactory<Expression>;
+    constructor();
+    setName(name: string): this;
+    setValue(builder: (a: ExpressionBuilder) => AstFactory<Expression>): this;
+}
+declare class MemberAccessExprFactory extends AstFactory<MemberAccessExpr> {
+    member?: Reference<MemberAccessTarget>;
+    operand?: AstFactory<Expression>;
+    constructor();
+    setMember(target: Reference<MemberAccessTarget>): this;
+    setOperand(builder: (b: ExpressionBuilder) => AstFactory<Expression>): this;
+}
+declare class ObjectExprFactory extends AstFactory<ObjectExpr> {
+    fields: FieldInitializerFactory[];
+    constructor();
+    addField(builder: (b: FieldInitializerFactory) => FieldInitializerFactory): this;
+}
+declare class FieldInitializerFactory extends AstFactory<FieldInitializer> {
+    name?: RegularID;
+    value?: AstFactory<Expression>;
+    constructor();
+    setName(name: RegularID): this;
+    setValue(builder: (a: ExpressionBuilder) => AstFactory<Expression>): this;
+}
+declare class InvocationExprFactory extends AstFactory<InvocationExpr> {
+    args: ArgumentFactory[];
+    function?: Reference<FunctionDecl>;
+    constructor();
+    addArg(builder: (arg: ArgumentFactory) => ArgumentFactory): this;
+    setFunction(value: FunctionDecl): this;
+}
+declare class ArgumentFactory extends AstFactory<Argument> {
+    value?: AstFactory<Expression>;
+    constructor();
+    setValue(builder: (a: ExpressionBuilder) => AstFactory<Expression>): this;
+}
+declare class ArrayExprFactory extends AstFactory<ArrayExpr> {
+    items: AstFactory<Expression>[];
+    constructor();
+    addItem(builder: (a: ExpressionBuilder) => AstFactory<Expression>): this;
+}
+declare class BinaryExprFactory extends AstFactory<BinaryExpr> {
+    operator?: BinaryExpr['operator'];
+    right?: AstFactory<Expression>;
+    left?: AstFactory<Expression>;
+    constructor();
+    setOperator(operator: BinaryExpr['operator']): this;
+    setRight(builder: (arg: ExpressionBuilder) => AstFactory<Expression>): this;
+    setLeft(builder: (arg: ExpressionBuilder) => AstFactory<Expression>): this;
+}
+
+declare class DataFieldAttributeFactory extends AstFactory<DataFieldAttribute> {
+    args: AttributeArgFactory[];
+    decl?: Reference<Attribute>;
+    constructor();
+    setDecl(decl: Attribute): this;
+    addArg(builder: (b: ExpressionBuilder) => AstFactory<Expression>, name?: string): this;
+}
+declare class DataModelAttributeFactory extends AstFactory<DataModelAttribute> {
+    args: AttributeArgFactory[];
+    decl?: Reference<Attribute>;
+    constructor();
+    setDecl(decl: Attribute): this;
+    addArg(builder: (b: ExpressionBuilder) => AstFactory<Expression>, name?: string): this;
+}
+declare class AttributeArgFactory extends AstFactory<AttributeArg> {
+    name?: RegularID;
+    value?: AstFactory<Expression>;
+    constructor();
+    setName(name: RegularID): this;
+    setValue(builder: (b: ExpressionBuilder) => AstFactory<Expression>): this;
+}
+declare class InternalAttributeFactory extends AstFactory<InternalAttribute> {
+    decl?: Reference<Attribute>;
+    args: AttributeArgFactory[];
+    constructor();
+    setDecl(decl: Attribute): this;
+    addArg(builder: (b: ExpressionBuilder) => AstFactory<Expression>, name?: string): this;
+}
+declare class AttributeParamFactory extends AstFactory<AttributeParam> {
+    attributes: InternalAttributeFactory[];
+    comments: string[];
+    default?: boolean;
+    name?: RegularID;
+    type?: AttributeParamTypeFactory;
+    constructor();
+    addAttribute(builder: (b: InternalAttributeFactory) => InternalAttributeFactory): this;
+    setComments(comments: string[]): this;
+    setDefault(defaultValue: boolean): this;
+    setName(name: string): this;
+    setType(builder: (b: AttributeParamTypeFactory) => AttributeParamTypeFactory): this;
+}
+declare class AttributeParamTypeFactory extends AstFactory<AttributeParamType> {
+    array?: boolean;
+    optional?: boolean;
+    reference?: Reference<TypeDeclaration>;
+    type?: AttributeParamType['type'];
+    constructor();
+    setArray(array: boolean): this;
+    setOptional(optional: boolean): this;
+    setReference(reference: TypeDeclaration): this;
+    setType(type: AttributeParamType['type']): this;
+}
+declare class AttributeFactory extends AstFactory<Attribute> {
+    name?: string;
+    comments: string[];
+    attributes: InternalAttributeFactory[];
+    params: AttributeParamFactory[];
+    constructor();
+    setName(name: string): this;
+    setComments(comments: string[]): this;
+    addAttribute(builder: (b: InternalAttributeFactory) => InternalAttributeFactory): this;
+    addParam(builder: (b: AttributeParamFactory) => AttributeParamFactory): this;
+}
+
+type DeclarationBuilderMap = ReturnType<typeof DeclarationBuilder>;
+declare const DeclarationBuilder: () => {
+    readonly Attribute: AttributeFactory;
+    readonly DataModel: DataModelFactory;
+    readonly DataSource: any;
+    readonly Enum: EnumFactory;
+    readonly FunctionDecl: any;
+    readonly GeneratorDecl: any;
+    readonly Plugin: any;
+    readonly Procedure: any;
+    readonly TypeDef: any;
+};
+type DeclarationBuilder<T extends AbstractDeclaration = AbstractDeclaration> = Pick<DeclarationBuilderMap, Extract<T['$type'], keyof DeclarationBuilderMap>>;
+declare class DataModelFactory extends AstFactory<DataModel> {
+    attributes: DataModelAttributeFactory[];
+    baseModel?: Reference<DataModel>;
+    comments: string[];
+    fields: DataFieldFactory[];
+    isView?: boolean;
+    mixins: Reference<TypeDef>[];
+    name?: RegularID;
+    constructor();
+    addAttribute(builder: (attr: DataModelAttributeFactory) => DataModelAttributeFactory): this;
+    setBaseModel(model: Reference<DataModel>): this;
+    setComments(comments: string[]): this;
+    addComment(comment: string): this;
+    addField(builder: (field: DataFieldFactory) => DataFieldFactory): this;
+    setIsView(isView: boolean): this;
+    addMixin(mixin: Reference<TypeDef>): this;
+    setName(name: string): this;
+}
+declare class DataFieldFactory extends AstFactory<DataField> {
+    attributes: DataFieldAttributeFactory[];
+    comments: string[];
+    name?: string;
+    type?: DataFieldTypeFactory;
+    constructor();
+    addAttribute(builder: ((attr: DataFieldAttributeFactory) => DataFieldAttributeFactory) | DataFieldAttributeFactory): this;
+    setComments(comments: string[]): this;
+    setName(name: string): this;
+    setType(builder: (type: DataFieldTypeFactory) => DataFieldTypeFactory): this;
+}
+declare class DataFieldTypeFactory extends AstFactory<DataFieldType> {
+    array?: boolean;
+    optional?: boolean;
+    reference?: Reference<TypeDeclaration>;
+    type?: BuiltinType;
+    unsupported?: UnsupportedFieldTypeFactory;
+    constructor();
+    setArray(array: boolean): this;
+    setOptional(optional: boolean): this;
+    setReference(reference: TypeDeclaration): this;
+    setType(type: BuiltinType): this;
+    setUnsupported(builder: (a: UnsupportedFieldTypeFactory) => UnsupportedFieldTypeFactory): this;
+}
+declare class UnsupportedFieldTypeFactory extends AstFactory<UnsupportedFieldType> {
+    value?: AstFactory<LiteralExpr>;
+    constructor();
+    setValue(builder: (value: ExpressionBuilder<LiteralExpr>) => AstFactory<LiteralExpr>): this;
+}
+declare class ModelFactory extends AstFactory<Model> {
+    declarations: AstFactory<AbstractDeclaration>[];
+    imports: ModelImportFactory[];
+    constructor();
+    addImport(builder: (b: ModelImportFactory) => ModelImportFactory): this;
+    addDeclaration(builder: (b: DeclarationBuilder) => AstFactory<AbstractDeclaration>): this;
+}
+declare class ModelImportFactory extends AstFactory<ModelImport> {
+    path?: string | undefined;
+    constructor();
+    setPath(path: string): this;
+}
+declare class EnumFactory extends AstFactory<Enum> {
+    name?: string;
+    comments: string[];
+    fields: EnumFieldFactory[];
+    attributes: DataModelAttributeFactory[];
+    constructor();
+    addField(builder: (b: EnumFieldFactory) => EnumFieldFactory): this;
+    addAttribute(builder: (b: DataModelAttributeFactory) => DataModelAttributeFactory): this;
+    setName(name: string): this;
+}
+declare class EnumFieldFactory extends AstFactory<EnumField> {
+    name?: RegularIDWithTypeNames;
+    comments: string[];
+    attributes: DataFieldAttributeFactory[];
+    constructor();
+    setName(name: RegularIDWithTypeNames): this;
+    addAttribute(builder: (b: DataFieldAttributeFactory) => DataFieldAttributeFactory): this;
+    addComment(comment: string): this;
+}
+
+export { ArgumentFactory, ArrayExprFactory, AstFactory, AttributeArgFactory, AttributeFactory, AttributeParamFactory, AttributeParamTypeFactory, BinaryExprFactory, BooleanLiteralFactory, type ContainerProps, DataFieldAttributeFactory, DataFieldFactory, DataFieldTypeFactory, DataModelAttributeFactory, DataModelFactory, DeclarationBuilder, EnumFactory, EnumFieldFactory, ExpressionBuilder, FieldInitializerFactory, InternalAttributeFactory, InvocationExprFactory, MemberAccessExprFactory, ModelFactory, ModelImportFactory, NullExprFactory, NumberLiteralFactory, ObjectExprFactory, ReferenceArgFactory, ReferenceExprFactory, StringLiteralFactory, ThisExprFactory, UnaryExprFactory, UnsupportedFieldTypeFactory };