@lowcodeunit/applications-flow-common 1.33.156-lets-get-social-ish → 1.33.157-lets-get-social-ish

package/esm2020/lib/services/project.service.mjs

@@ -0,0 +1,323 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./applications-flow.service";
+export class ProjectService {
+    constructor(appsFlowSvc) {
+        this.appsFlowSvc = appsFlowSvc;
+    }
+    // public CreateRepository(state: ApplicationsFlowState, org: string, repoName: string): void {
+    //   state.GitHub.Loading = true;
+    //   this.appsFlowSvc
+    //     .CreateRepository(org, repoName)
+    //     .subscribe((response: BaseResponse) => {
+    //       if (response.Status.Code === 0) {
+    //         this.listRepositories(repoName);
+    //         state.GitHub.CreatingRepository = false;
+    //       } else {
+    //         //  TODO:  Need to surface an error to the user...
+    //         state.GitHub.Loading = false;
+    //       }
+    //     });
+    // }
+    async DeleteApplication(state, appLookup) {
+        return new Promise((resolve, reject) => {
+            state.Loading = true;
+            this.appsFlowSvc.DeleteApplication(appLookup).subscribe(async (response) => {
+                if (response.Status.Code === 0) {
+                    const eac = await this.LoadEnterpriseAsCode(state);
+                    resolve(eac);
+                }
+                else {
+                    state.Loading = false;
+                    reject(response.Status);
+                    console.log(response);
+                }
+            }, (err) => {
+                state.Loading = false;
+                reject(err);
+                console.log(err);
+            });
+        });
+    }
+    DeleteDevOpsAction(state, doaLookup) {
+        return new Promise((resolve, reject) => {
+            state.Loading = true;
+            this.appsFlowSvc.DeleteDevOpsAction(doaLookup).subscribe(async (response) => {
+                if (response.Status.Code === 0) {
+                    const eac = await this.LoadEnterpriseAsCode(state);
+                    resolve(eac);
+                }
+                else {
+                    state.Loading = false;
+                    reject(response.Status);
+                    console.log(response);
+                }
+            }, (err) => {
+                state.Loading = false;
+                reject(err);
+                console.log(err);
+            });
+        });
+    }
+    DeleteProject(state, projectLookup) {
+        return new Promise((resolve, reject) => {
+            state.Loading = true;
+            this.appsFlowSvc.DeleteProject(projectLookup).subscribe(async (response) => {
+                if (response.Status.Code === 0) {
+                    const eac = await this.LoadEnterpriseAsCode(state);
+                    resolve(eac);
+                }
+                else {
+                    state.Loading = false;
+                    reject(response.Status);
+                    console.log(response);
+                }
+            }, (err) => {
+                state.Loading = false;
+                reject(err);
+                console.log(err);
+            });
+        });
+    }
+    DeleteSourceControl(state, scLookup) {
+        return new Promise((resolve, reject) => {
+            state.Loading = true;
+            this.appsFlowSvc.DeleteSourceControl(scLookup).subscribe(async (response) => {
+                if (response.Status.Code === 0) {
+                    const eac = await this.LoadEnterpriseAsCode(state);
+                    resolve(eac);
+                }
+                else {
+                    state.Loading = false;
+                    reject(response.Status);
+                    console.log(response);
+                }
+            }, (err) => {
+                state.Loading = false;
+                reject(err);
+                console.log(err);
+            });
+        });
+    }
+    EnsureUserEnterprise(state) {
+        return new Promise((resolve, reject) => {
+            state.Loading = true;
+            this.appsFlowSvc.EnsureUserEnterprise().subscribe(async (response) => {
+                if (response.Status.Code === 0) {
+                    const eac = await this.LoadEnterpriseAsCode(state);
+                    resolve(eac);
+                }
+                else {
+                    state.Loading = false;
+                    reject(response.Status);
+                    console.log(response);
+                }
+            }, (err) => {
+                state.Loading = false;
+                reject(err);
+                console.log(err);
+            });
+        });
+    }
+    async GetActiveEnterprise(state) {
+        return new Promise((resolve, reject) => {
+            state.Loading = true;
+            this.appsFlowSvc.GetActiveEnterprise().subscribe(async (response) => {
+                if (response.Status.Code === 0) {
+                    state.ActiveEnterpriseLookup = response.Model?.Lookup;
+                    state.Loading = false;
+                    resolve();
+                }
+                else {
+                    state.Loading = false;
+                    reject(response.Status);
+                    console.log(response);
+                }
+            }, (err) => {
+                state.Loading = false;
+                reject(err);
+                console.log(err);
+            });
+        });
+    }
+    HasValidConnection(state, forceEnsureUser = false) {
+        return new Promise(async (resolve, reject) => {
+            state.Loading = true;
+            this.appsFlowSvc.HasValidConnection().subscribe(async (response) => {
+                state.GitHub.HasConnection = response.Status.Code === 0;
+                if (state.GitHub.HasConnection || forceEnsureUser) {
+                }
+                else {
+                }
+                resolve({});
+            }, (err) => {
+                state.Loading = false;
+                reject(err);
+                console.log(err);
+            });
+        });
+    }
+    async ListEnterprises(state) {
+        return new Promise((resolve, reject) => {
+            state.Loading = true;
+            this.appsFlowSvc.ListEnterprises().subscribe(async (response) => {
+                state.Loading = false;
+                if (response.Status.Code === 0) {
+                    state.Enterprises = response.Model;
+                    resolve(response.Model);
+                }
+                else {
+                    reject(response.Status);
+                    console.log(response);
+                }
+            }, (err) => {
+                state.Loading = false;
+                reject(err);
+                console.log(err);
+            });
+        });
+    }
+    LoadEnterpriseAsCode(state) {
+        return new Promise((resolve, reject) => {
+            state.Loading = true;
+            this.appsFlowSvc.LoadEnterpriseAsCode().subscribe((response) => {
+                state.Loading = false;
+                if (response.Status.Code === 0) {
+                    state.EaC = response.Model || {};
+                }
+                else if (response.Status.Code === 3) {
+                }
+                state.EaC = state.EaC || {};
+                this.CreatingProject =
+                    Object.keys(state?.EaC?.Projects || {}).length <= 0;
+                if (this.CreatingProject) {
+                    window.location.href = '/dashboard/create-project';
+                }
+                resolve(state.EaC);
+                console.log(state);
+            }, (err) => {
+                state.Loading = false;
+                reject(err);
+                console.log(err);
+            });
+        });
+    }
+    async SetActiveEnterprise(state, activeEntLookup) {
+        return new Promise((resolve, reject) => {
+            state.Loading = true;
+            this.appsFlowSvc.SetActiveEnterprise(activeEntLookup).subscribe(async (response) => {
+                if (response.Status.Code === 0) {
+                    this.EditingProjectLookup = null;
+                    state.ActiveEnterpriseLookup = activeEntLookup;
+                    const eac = await this.LoadEnterpriseAsCode(state);
+                    resolve(eac);
+                }
+                else {
+                    state.Loading = false;
+                    reject(response.Status);
+                    console.log(response);
+                }
+            }, (err) => {
+                state.Loading = false;
+                reject(err);
+                console.log(err);
+            });
+        });
+    }
+    async SaveEnterpriseAsCode(state, eac) {
+        return new Promise((resolve, reject) => {
+            state.Loading = true;
+            this.appsFlowSvc.SaveEnterpriseAsCode(eac).subscribe(async (response) => {
+                if (response.Status.Code === 0) {
+                    eac = await this.LoadEnterpriseAsCode(state);
+                    resolve(eac);
+                }
+                else {
+                    state.Loading = false;
+                    reject(response.Status);
+                    console.log(response);
+                }
+            }, (err) => {
+                state.Loading = false;
+                reject(err);
+                console.log(err);
+            });
+        });
+    }
+    SetCreatingProject(creatingProject) {
+        this.CreatingProject = creatingProject;
+        this.EditingProjectLookup = null;
+    }
+    SetEditProjectSettings(state, projectLookup) {
+        return new Promise((resolve, reject) => {
+            if (projectLookup != null) {
+                state.Loading = false;
+                this.EditingProjectLookup = null;
+                setTimeout(() => {
+                    this.EditingProjectLookup = projectLookup;
+                    resolve({});
+                }, 0);
+                this.CreatingProject = false;
+                console.log(state);
+            }
+            else {
+                state.Loading = false;
+                this.EditingProjectLookup = projectLookup;
+                this.CreatingProject = false;
+                resolve({});
+            }
+        });
+    }
+    ToggleCreateProject() {
+        this.SetCreatingProject(!this.CreatingProject);
+    }
+    UnpackLowCodeUnit(state, req) {
+        return new Promise((resolve, reject) => {
+            state.Loading = true;
+            this.appsFlowSvc.UnpackLowCodeUnit(req).subscribe(async (response) => {
+                if (response.Status.Code === 0) {
+                    const eac = await this.LoadEnterpriseAsCode(state);
+                    resolve(eac);
+                }
+                else {
+                    state.Loading = false;
+                    reject(response.Status);
+                    console.log(response);
+                }
+            }, (err) => {
+                state.Loading = false;
+                reject(err);
+                console.log(err);
+            });
+        });
+    }
+    async UserFeed(page, pageSize, state) {
+        return new Promise((resolve, reject) => {
+            state.Loading = true;
+            this.appsFlowSvc.UserFeed(page, pageSize).subscribe(async (response) => {
+                state.Loading = false;
+                if (response.Status.Code === 0) {
+                    state.Feed = response.Items;
+                    resolve(response.Items);
+                }
+                else {
+                    reject(response.Status);
+                    console.log(response);
+                }
+            }, (err) => {
+                state.Loading = false;
+                reject(err);
+                console.log(err);
+            });
+        });
+    }
+}
+ProjectService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: ProjectService, deps: [{ token: i1.ApplicationsFlowService }], target: i0.ɵɵFactoryTarget.Injectable });
+ProjectService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: ProjectService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: ProjectService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ApplicationsFlowService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"project.service.js","sourceRoot":"","sources":["../../../../../projects/common/src/lib/services/project.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { BaseModeledResponse, BaseResponse } from '@lcu/common';\nimport { debug } from 'console';\nimport { EaCProjectAsCode, EnterpriseAsCode } from '@semanticjs/common';\nimport {\n  ApplicationsFlowState,\n  GitHubWorkflowRun,\n  UnpackLowCodeUnitRequest,\n} from '../state/applications-flow.state';\nimport { ApplicationsFlowService } from './applications-flow.service';\nimport { FeedItem, UserFeedResponse } from '../models/user-feed.model';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ProjectService {\n  public CreatingProject: boolean;\n\n  public EditingProjectLookup: string;\n\n  constructor(protected appsFlowSvc: ApplicationsFlowService) {}\n\n  // public CreateRepository(state: ApplicationsFlowState, org: string, repoName: string): void {\n  //   state.GitHub.Loading = true;\n\n  //   this.appsFlowSvc\n  //     .CreateRepository(org, repoName)\n  //     .subscribe((response: BaseResponse) => {\n  //       if (response.Status.Code === 0) {\n  //         this.listRepositories(repoName);\n\n  //         state.GitHub.CreatingRepository = false;\n  //       } else {\n  //         //  TODO:  Need to surface an error to the user...\n\n  //         state.GitHub.Loading = false;\n  //       }\n  //     });\n  // }\n\n  public async DeleteApplication(\n    state: ApplicationsFlowState,\n    appLookup: string\n  ): Promise<EnterpriseAsCode> {\n    return new Promise((resolve, reject) => {\n      state.Loading = true;\n\n      this.appsFlowSvc.DeleteApplication(appLookup).subscribe(\n        async (response: BaseResponse) => {\n          if (response.Status.Code === 0) {\n            const eac = await this.LoadEnterpriseAsCode(state);\n\n            resolve(eac);\n          } else {\n            state.Loading = false;\n\n            reject(response.Status);\n\n            console.log(response);\n          }\n        },\n        (err) => {\n          state.Loading = false;\n\n          reject(err);\n\n          console.log(err);\n        }\n      );\n    });\n  }\n\n  public DeleteDevOpsAction(\n    state: ApplicationsFlowState,\n    doaLookup: string\n  ): Promise<EnterpriseAsCode> {\n    return new Promise((resolve, reject) => {\n      state.Loading = true;\n\n      this.appsFlowSvc.DeleteDevOpsAction(doaLookup).subscribe(\n        async (response: BaseResponse) => {\n          if (response.Status.Code === 0) {\n            const eac = await this.LoadEnterpriseAsCode(state);\n\n            resolve(eac);\n          } else {\n            state.Loading = false;\n\n            reject(response.Status);\n\n            console.log(response);\n          }\n        },\n        (err) => {\n          state.Loading = false;\n\n          reject(err);\n\n          console.log(err);\n        }\n      );\n    });\n  }\n\n  public DeleteProject(\n    state: ApplicationsFlowState,\n    projectLookup: string\n  ): Promise<EnterpriseAsCode> {\n    return new Promise((resolve, reject) => {\n      state.Loading = true;\n\n      this.appsFlowSvc.DeleteProject(projectLookup).subscribe(\n        async (response: BaseResponse) => {\n          if (response.Status.Code === 0) {\n            const eac = await this.LoadEnterpriseAsCode(state);\n\n            resolve(eac);\n          } else {\n            state.Loading = false;\n\n            reject(response.Status);\n\n            console.log(response);\n          }\n        },\n        (err) => {\n          state.Loading = false;\n\n          reject(err);\n\n          console.log(err);\n        }\n      );\n    });\n  }\n\n  public DeleteSourceControl(\n    state: ApplicationsFlowState,\n    scLookup: string\n  ): Promise<EnterpriseAsCode> {\n    return new Promise((resolve, reject) => {\n      state.Loading = true;\n\n      this.appsFlowSvc.DeleteSourceControl(scLookup).subscribe(\n        async (response: BaseResponse) => {\n          if (response.Status.Code === 0) {\n            const eac = await this.LoadEnterpriseAsCode(state);\n\n            resolve(eac);\n          } else {\n            state.Loading = false;\n\n            reject(response.Status);\n\n            console.log(response);\n          }\n        },\n        (err) => {\n          state.Loading = false;\n\n          reject(err);\n\n          console.log(err);\n        }\n      );\n    });\n  }\n\n  public EnsureUserEnterprise(\n    state: ApplicationsFlowState\n  ): Promise<EnterpriseAsCode> {\n    return new Promise((resolve, reject) => {\n      state.Loading = true;\n\n      this.appsFlowSvc.EnsureUserEnterprise().subscribe(\n        async (response: BaseResponse) => {\n          if (response.Status.Code === 0) {\n            const eac = await this.LoadEnterpriseAsCode(state);\n\n            resolve(eac);\n          } else {\n            state.Loading = false;\n\n            reject(response.Status);\n\n            console.log(response);\n          }\n        },\n        (err) => {\n          state.Loading = false;\n\n          reject(err);\n\n          console.log(err);\n        }\n      );\n    });\n  }\n\n  public async GetActiveEnterprise(\n    state: ApplicationsFlowState\n  ): Promise<void> {\n    return new Promise((resolve, reject) => {\n      state.Loading = true;\n\n      this.appsFlowSvc.GetActiveEnterprise().subscribe(\n        async (\n          response: BaseModeledResponse<{ Name: string; Lookup: string }>\n        ) => {\n          if (response.Status.Code === 0) {\n            state.ActiveEnterpriseLookup = response.Model?.Lookup;\n\n            state.Loading = false;\n\n            resolve();\n          } else {\n            state.Loading = false;\n\n            reject(response.Status);\n\n            console.log(response);\n          }\n        },\n        (err) => {\n          state.Loading = false;\n\n          reject(err);\n\n          console.log(err);\n        }\n      );\n    });\n  }\n\n  public HasValidConnection(\n    state: ApplicationsFlowState,\n    forceEnsureUser: boolean = false\n  ): Promise<EnterpriseAsCode> {\n    return new Promise(async (resolve, reject) => {\n      state.Loading = true;\n\n      this.appsFlowSvc.HasValidConnection().subscribe(\n        async (response: BaseResponse) => {\n          state.GitHub.HasConnection = response.Status.Code === 0;\n\n          if (state.GitHub.HasConnection || forceEnsureUser) {\n          } else {\n          }\n\n          resolve({});\n        },\n        (err) => {\n          state.Loading = false;\n\n          reject(err);\n\n          console.log(err);\n        }\n      );\n    });\n  }\n\n  public async ListEnterprises(state: ApplicationsFlowState): Promise<any[]> {\n    return new Promise((resolve, reject) => {\n      state.Loading = true;\n\n      this.appsFlowSvc.ListEnterprises().subscribe(\n        async (response: BaseModeledResponse<Array<any>>) => {\n          state.Loading = false;\n\n          if (response.Status.Code === 0) {\n            state.Enterprises = response.Model;\n\n            resolve(response.Model);\n          } else {\n            reject(response.Status);\n\n            console.log(response);\n          }\n        },\n        (err) => {\n          state.Loading = false;\n\n          reject(err);\n\n          console.log(err);\n        }\n      );\n    });\n  }\n\n  public LoadEnterpriseAsCode(\n    state: ApplicationsFlowState\n  ): Promise<EnterpriseAsCode> {\n    return new Promise((resolve, reject) => {\n      state.Loading = true;\n\n      this.appsFlowSvc.LoadEnterpriseAsCode().subscribe(\n        (response: BaseModeledResponse<EnterpriseAsCode>) => {\n          state.Loading = false;\n\n          if (response.Status.Code === 0) {\n            state.EaC = response.Model || {};\n          } else if (response.Status.Code === 3) {\n          }\n\n          state.EaC = state.EaC || {};\n\n          this.CreatingProject =\n            Object.keys(state?.EaC?.Projects || {}).length <= 0;\n\n          if (this.CreatingProject) {\n            window.location.href = '/dashboard/create-project';\n          }\n\n          resolve(state.EaC);\n\n          console.log(state);\n        },\n        (err) => {\n          state.Loading = false;\n\n          reject(err);\n\n          console.log(err);\n        }\n      );\n    });\n  }\n\n  public async SetActiveEnterprise(\n    state: ApplicationsFlowState,\n    activeEntLookup: string\n  ): Promise<EnterpriseAsCode> {\n    return new Promise((resolve, reject) => {\n      state.Loading = true;\n\n      this.appsFlowSvc.SetActiveEnterprise(activeEntLookup).subscribe(\n        async (response: BaseResponse) => {\n          if (response.Status.Code === 0) {\n            this.EditingProjectLookup = null;\n\n            state.ActiveEnterpriseLookup = activeEntLookup;\n\n            const eac = await this.LoadEnterpriseAsCode(state);\n\n            resolve(eac);\n          } else {\n            state.Loading = false;\n\n            reject(response.Status);\n\n            console.log(response);\n          }\n        },\n        (err) => {\n          state.Loading = false;\n\n          reject(err);\n\n          console.log(err);\n        }\n      );\n    });\n  }\n\n  public async SaveEnterpriseAsCode(\n    state: ApplicationsFlowState,\n    eac: EnterpriseAsCode\n  ): Promise<EnterpriseAsCode> {\n    return new Promise((resolve, reject) => {\n      state.Loading = true;\n\n      this.appsFlowSvc.SaveEnterpriseAsCode(eac).subscribe(\n        async (response: BaseModeledResponse<string>) => {\n          if (response.Status.Code === 0) {\n            eac = await this.LoadEnterpriseAsCode(state);\n\n            resolve(eac);\n          } else {\n            state.Loading = false;\n\n            reject(response.Status);\n\n            console.log(response);\n          }\n        },\n        (err) => {\n          state.Loading = false;\n\n          reject(err);\n\n          console.log(err);\n        }\n      );\n    });\n  }\n\n  public SetCreatingProject(creatingProject: boolean): void {\n    this.CreatingProject = creatingProject;\n\n    this.EditingProjectLookup = null;\n  }\n\n  public SetEditProjectSettings(\n    state: ApplicationsFlowState,\n    projectLookup: string\n  ): Promise<any> {\n    return new Promise((resolve, reject) => {\n      if (projectLookup != null) {\n        state.Loading = false;\n\n        this.EditingProjectLookup = null;\n\n        setTimeout(() => {\n          this.EditingProjectLookup = projectLookup;\n\n          resolve({});\n        }, 0);\n\n        this.CreatingProject = false;\n\n        console.log(state);\n      } else {\n        state.Loading = false;\n\n        this.EditingProjectLookup = projectLookup;\n\n        this.CreatingProject = false;\n\n        resolve({});\n      }\n    });\n  }\n\n  public ToggleCreateProject(): void {\n    this.SetCreatingProject(!this.CreatingProject);\n  }\n\n  public UnpackLowCodeUnit(\n    state: ApplicationsFlowState,\n    req: UnpackLowCodeUnitRequest\n  ): Promise<EnterpriseAsCode> {\n    return new Promise((resolve, reject) => {\n      state.Loading = true;\n\n      this.appsFlowSvc.UnpackLowCodeUnit(req).subscribe(\n        async (response: BaseResponse) => {\n          if (response.Status.Code === 0) {\n            const eac = await this.LoadEnterpriseAsCode(state);\n\n            resolve(eac);\n          } else {\n            state.Loading = false;\n\n            reject(response.Status);\n\n            console.log(response);\n          }\n        },\n        (err) => {\n          state.Loading = false;\n\n          reject(err);\n\n          console.log(err);\n        }\n      );\n    });\n  }\n\n  public async UserFeed(page: number, pageSize: number, state: ApplicationsFlowState): Promise<Array<FeedItem>> {\n    return new Promise((resolve, reject) => {\n      state.Loading = true;\n\n      this.appsFlowSvc.UserFeed(page, pageSize).subscribe(\n        async (response: UserFeedResponse) => {\n          state.Loading = false;\n\n          if (response.Status.Code === 0) {\n            state.Feed = response.Items;\n\n            resolve(response.Items);\n          } else {\n            reject(response.Status);\n\n            console.log(response);\n          }\n        },\n        (err) => {\n          state.Loading = false;\n\n          reject(err);\n\n          console.log(err);\n        }\n      );\n    });\n  }\n}\n"]}

package/esm2020/lib/state/applications-flow-state.context.mjs

@@ -0,0 +1,36 @@
+import { Injectable } from '@angular/core';
+import { StateContext } from '@lcu/common';
+import * as i0 from "@angular/core";
+export class ApplicationsFlowStateContext extends StateContext {
+    // Constructors
+    constructor(injector) {
+        super(injector);
+        this.injector = injector;
+    }
+    // API Methods
+    AddApplication() {
+        this.Execute({
+            Arguments: {},
+            Type: 'AddApplication'
+        });
+    }
+    //  Helpers
+    defaultValue() {
+        return { Loading: true };
+    }
+    loadStateKey() {
+        return 'main';
+    }
+    loadStateName() {
+        return 'lcu';
+    }
+}
+ApplicationsFlowStateContext.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: ApplicationsFlowStateContext, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+ApplicationsFlowStateContext.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: ApplicationsFlowStateContext, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: ApplicationsFlowStateContext, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/state/applications-flow.state.mjs

@@ -0,0 +1,72 @@
+export class ApplicationsFlowState {
+    constructor() {
+        this.GitHub = {};
+        this.HostingDetails = {};
+        this.Loading = true;
+        // this.Projects = [];
+    }
+}
+// export class ProjectState {
+//   public ActionsSet?: { [id: string]: DevOpsAction };
+//   public Applications?: ApplicationState[];
+//   public Description?: string;
+//   public Host?: string;
+//   public ID?: string;
+//   public Image?: string;
+//   public LCUs?: GitHubLowCodeUnit[];
+//   public Name?: string;
+//   public PreventInheritedApplications?: boolean;
+//   public Runs?: GitHubWorkflowRun[];
+// }
+// export class ApplicationState {
+//   public IsPrivate?: boolean;
+//   public Name?: string;
+//   public Organization?: string;
+//   public PathRegex?: string;
+//   public Priority?: number;
+//   public Repository?: string;
+//   public Version?: string;
+// }
+export class GitHubSetupState {
+}
+export class GitHubBranch {
+}
+// export class GitHubLowCodeUnit {
+//   public Branch?: string;
+//   public ID?: string;
+//   public Lookup?: string;
+//   public Organization?: string;
+//   public Repository?: string;
+// }
+export class GitHubOrganization {
+}
+export class GitHubRepository {
+}
+export class GitHubWorkflowRun {
+}
+export class UnpackLowCodeUnitRequest {
+}
+// export class DevOpsAction {
+//   public Details?: string;
+//   public ID?: string;
+//   public Name?: string;
+//   public Overwrite?: boolean;
+//   public Path?: string;
+//   public Template?: string;
+// }
+export class ProjectHostingDetails {
+}
+export class ProjectHostingOption {
+}
+export class ProjectHostingOptionInput {
+}
+// export class EstablishProjectRequest {
+//   public Branch?: string;
+//   public BuildScript?: string;
+//   public HostingOption?: string;
+//   public Organization?: string;
+//   public OutputFolder?: string;
+//   public ProjectName?: string;
+//   public Repository?: string;
+// }
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lowcodeunit-applications-flow-common.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './lcu.api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG93Y29kZXVuaXQtYXBwbGljYXRpb25zLWZsb3ctY29tbW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vcHJvamVjdHMvY29tbW9uL3NyYy9sb3djb2RldW5pdC1hcHBsaWNhdGlvbnMtZmxvdy1jb21tb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFdBQVcsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9sY3UuYXBpJztcbiJdfQ==