@lowcodeunit/applications-flow-common 0.0.2 → 0.0.4

package/lib/services/applications-flow.service.d.ts

@@ -1,27 +1,39 @@
 import { HttpClient } from '@angular/common/http';
 import { LCUServiceSettings } from '@lcu/common';
 import { Observable } from 'rxjs';
-import { EstablishProjectRequest, GitHubLowCodeUnit, ProjectState } from '../state/applications-flow.state';
-import { GitHubWorkflowRun } from './../state/applications-flow.state';
+import { EnterpriseAsCode } from '@semanticjs/common';
+import { UnpackLowCodeUnitRequest } from '../state/applications-flow.state';
+import * as i0 from "@angular/core";
 export declare class ApplicationsFlowService {
     protected http: HttpClient;
     protected settings: LCUServiceSettings;
     protected apiRoot: string;
     constructor(http: HttpClient, settings: LCUServiceSettings);
-    BootUserEnterprise(request: EstablishProjectRequest): Observable<object>;
-    ConfigureGitHubLCUDevOps(projectId: string, lcu: GitHubLowCodeUnit): Observable<object>;
+    ConfigureDevOpsAction(actionLookup: string): Observable<object>;
     CreateRepository(organization: string, repoName: string): Observable<object>;
-    DeployRun(run: GitHubWorkflowRun): Observable<object>;
+    DeleteApplication(appLookup: string): Observable<object>;
+    DeleteDevOpsAction(doaLookup: string): Observable<object>;
+    DeleteProject(projectLookup: string): Observable<object>;
+    DeleteSourceControl(scLookup: string): Observable<object>;
+    EnsureUserEnterprise(): Observable<object>;
+    GetActiveEnterprise(): Observable<object>;
     HasValidConnection(): Observable<object>;
-    IsolateHostDNSInstance(): Observable<object>;
     ListProjects(): Observable<object>;
     ListBranches(organization: string, repository: string): Observable<object>;
+    ListBuildPaths(organization: string, repository: string, branch?: string): Observable<object>;
+    ListEnterprises(): Observable<object>;
     ListOrganizations(): Observable<object>;
     ListRepositories(organization: string): Observable<object>;
+    LoadEnterpriseAsCode(): Observable<object>;
     LoadProjectHostingDetails(organization: string, repository: string, branch: string): Observable<object>;
-    SaveProject(project: ProjectState, hostDnsInstance: string): Observable<object>;
+    NewLoadProjectHostingDetails(): Observable<object>;
+    SaveEnterpriseAsCode(eac: EnterpriseAsCode): Observable<object>;
+    SetActiveEnterprise(activeEntLookup: string): Observable<object>;
+    UnpackLowCodeUnit(req: UnpackLowCodeUnitRequest): Observable<object>;
+    LoadUserFeed(page: number, pageSize: number): Observable<object>;
     protected loadHeaders(): {
         [header: string]: string | string[];
     };
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApplicationsFlowService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApplicationsFlowService>;
 }
-//# sourceMappingURL=applications-flow.service.d.ts.map

package/lib/services/eac.service.d.ts

@@ -0,0 +1,63 @@
+import { ProjectService } from './project.service';
+import { ApplicationsFlowState, UnpackLowCodeUnitRequest } from '../state/applications-flow.state';
+import { EaCApplicationAsCode, EaCDataToken, EaCDFSModifier, EaCEnvironmentAsCode, EaCProjectAsCode, EnterpriseAsCode } from '@semanticjs/common';
+import { FeedItem } from '../models/user-feed.model';
+import { HttpClient } from '@angular/common/http';
+import { Status } from '@lcu/common';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class SaveApplicationAsCodeEventRequest {
+    Application?: EaCApplicationAsCode;
+    ApplicationLookup?: string;
+    ProjectLookup?: string;
+}
+export declare class SaveDFSModifierEventRequest {
+    Modifier: EaCDFSModifier;
+    ModifierLookup: string;
+    ProjectLookup?: string;
+}
+export declare class SaveEnvironmentAsCodeEventRequest {
+    EnterpriseDataTokens?: {
+        [lookup: string]: EaCDataToken;
+    };
+    Environment?: EaCEnvironmentAsCode;
+    EnvironmentLookup?: string;
+}
+export declare class SaveProjectAsCodeEventRequest {
+    Project?: EaCProjectAsCode;
+    ProjectLookup?: string;
+}
+export declare class EaCService {
+    protected projectService: ProjectService;
+    protected http: HttpClient;
+    get EditingProjectLookup(): string;
+    get CreatingProject(): boolean;
+    State: ApplicationsFlowState;
+    constructor(projectService: ProjectService, http: HttpClient);
+    CheckUserFeedItem(feedItem: FeedItem): Observable<object>;
+    DeleteApplication(appLookup: string, appName: string): Promise<void>;
+    DeleteDevOpsAction(doaLookup: string): Promise<void>;
+    DeleteProject(projectLookup: string): Promise<void>;
+    DeleteSourceControl(scLookup: string): Promise<void>;
+    EnsureUserEnterprise(): Promise<void>;
+    GetActiveEnterprise(): Promise<void>;
+    LoadUserFeed(page: number, pageSize: number): Promise<void>;
+    HasValidConnection(): Promise<void>;
+    ListEnterprises(): Promise<void>;
+    LoadEnterpriseAsCode(): Promise<void>;
+    SaveApplicationAsCode(req: SaveApplicationAsCodeEventRequest): Promise<Status>;
+    SaveDFSModifier(req: SaveDFSModifierEventRequest): Promise<void>;
+    SaveEnterpriseAsCode(eac: EnterpriseAsCode): Promise<Status>;
+    SaveEnvironmentAsCode(req: SaveEnvironmentAsCodeEventRequest): Promise<Status>;
+    SaveProjectAsCode(req: SaveProjectAsCodeEventRequest): Promise<void>;
+    SetActiveEnterprise(entLookup: any): Promise<void>;
+    SetCreatingProject(creatingProject: boolean): Promise<void>;
+    SetEditProjectSettings(projectLookup: string): Promise<void>;
+    UnpackLowCodeUnit(req: UnpackLowCodeUnitRequest): Promise<void>;
+    protected handleSaveApplication(req: SaveApplicationAsCodeEventRequest): Promise<Status>;
+    protected handleSaveDFSModifier(req: SaveDFSModifierEventRequest): Promise<void>;
+    protected handleSaveEnvironment(req: SaveEnvironmentAsCodeEventRequest): Promise<Status>;
+    protected handleSaveProject(projectLookup: string, project: EaCProjectAsCode): Promise<Status>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EaCService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EaCService>;
+}

package/lib/services/forms.service.d.ts

@@ -2,6 +2,7 @@ import { FormValuesModel } from './../models/form.values.model';
 import { FormModel } from './../models/form.model';
 import { FormGroup } from '@angular/forms';
 import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
 export declare class FormsService {
     /**
      * List of forms
@@ -64,5 +65,6 @@ export declare class FormsService {
      */
     ForRealThough(id: string, formToCheck: FormGroup): boolean;
     constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FormsService>;
 }
-//# sourceMappingURL=forms.service.d.ts.map

package/lib/services/npm.service.d.ts

@@ -0,0 +1,13 @@
+import { Injector } from '@angular/core';
+import { DAFService, BaseModeledResponse, Pageable } from '@lcu/common';
+import { Observable } from 'rxjs';
+import { HttpBackend } from '@angular/common/http';
+import * as i0 from "@angular/core";
+export declare class NPMService extends DAFService {
+    protected injector: Injector;
+    constructor(injector: Injector, handler: HttpBackend);
+    Search(search: string): Observable<BaseModeledResponse<Pageable<any>>>;
+    Versions(npmPkg: string): Observable<BaseModeledResponse<Pageable<any>>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NPMService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NPMService>;
+}

package/lib/services/project.service.d.ts

@@ -1,14 +1,30 @@
-import { ApplicationsFlowState, GitHubWorkflowRun, ProjectState } from '../state/applications-flow.state';
+import { Status } from '@lcu/common';
+import { EnterpriseAsCode } from '@semanticjs/common';
+import { ApplicationsFlowState, UnpackLowCodeUnitRequest } from '../state/applications-flow.state';
 import { ApplicationsFlowService } from './applications-flow.service';
+import { FeedItem } from '../models/user-feed.model';
+import * as i0 from "@angular/core";
 export declare class ProjectService {
     protected appsFlowSvc: ApplicationsFlowService;
     CreatingProject: boolean;
-    EditingProjectID: string;
+    EditingProjectLookup: string;
     constructor(appsFlowSvc: ApplicationsFlowService);
-    DeployRun(state: ApplicationsFlowState, run: GitHubWorkflowRun): void;
-    ListProjects(state: ApplicationsFlowState, withLoading?: boolean): void;
-    SaveProject(state: ApplicationsFlowState, project: ProjectState): void;
-    SetEditProjectSettings(state: ApplicationsFlowState, project: ProjectState): void;
+    DeleteApplication(state: ApplicationsFlowState, appLookup: string): Promise<EnterpriseAsCode>;
+    DeleteDevOpsAction(state: ApplicationsFlowState, doaLookup: string): Promise<EnterpriseAsCode>;
+    DeleteProject(state: ApplicationsFlowState, projectLookup: string): Promise<EnterpriseAsCode>;
+    DeleteSourceControl(state: ApplicationsFlowState, scLookup: string): Promise<EnterpriseAsCode>;
+    EnsureUserEnterprise(state: ApplicationsFlowState): Promise<EnterpriseAsCode>;
+    GetActiveEnterprise(state: ApplicationsFlowState): Promise<void>;
+    LoadUserFeed(page: number, pageSize: number, state: ApplicationsFlowState): Promise<Array<FeedItem>>;
+    HasValidConnection(state: ApplicationsFlowState, forceEnsureUser?: boolean): Promise<EnterpriseAsCode>;
+    ListEnterprises(state: ApplicationsFlowState): Promise<any[]>;
+    LoadEnterpriseAsCode(state: ApplicationsFlowState): Promise<EnterpriseAsCode>;
+    SetActiveEnterprise(state: ApplicationsFlowState, activeEntLookup: string): Promise<EnterpriseAsCode>;
+    SaveEnterpriseAsCode(state: ApplicationsFlowState, eac: EnterpriseAsCode): Promise<Status>;
+    SetCreatingProject(creatingProject: boolean): void;
+    SetEditProjectSettings(state: ApplicationsFlowState, projectLookup: string): Promise<any>;
     ToggleCreateProject(): void;
+    UnpackLowCodeUnit(state: ApplicationsFlowState, req: UnpackLowCodeUnitRequest): Promise<EnterpriseAsCode>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProjectService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProjectService>;
 }
-//# sourceMappingURL=project.service.d.ts.map

package/lib/state/applications-flow-state.context.d.ts

@@ -1,6 +1,7 @@
 import { Injector } from '@angular/core';
 import { StateContext } from '@lcu/common';
 import { ApplicationsFlowState } from './applications-flow.state';
+import * as i0 from "@angular/core";
 export declare class ApplicationsFlowStateContext extends StateContext<ApplicationsFlowState> {
     protected injector: Injector;
     constructor(injector: Injector);
@@ -8,5 +9,6 @@ export declare class ApplicationsFlowStateContext extends StateContext<Applicati
     protected defaultValue(): ApplicationsFlowState;
     protected loadStateKey(): string;
     protected loadStateName(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApplicationsFlowStateContext, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApplicationsFlowStateContext>;
 }
-//# sourceMappingURL=applications-flow-state.context.d.ts.map

package/lib/state/applications-flow.state.d.ts

@@ -1,25 +1,23 @@
+import { EnterpriseAsCode } from '@semanticjs/common';
+import { FeedItem } from '../models/user-feed.model';
 export declare class ApplicationsFlowState {
+    ActiveEnterpriseLookup?: string;
+    EaC?: EnterpriseAsCode;
+    Enterprises?: Array<{
+        Name: string;
+        Lookup: string;
+    }>;
+    Feed?: Array<FeedItem>;
     GitHub?: GitHubSetupState;
-    HostDNSInstance?: string;
     HostingDetails?: ProjectHostingDetails;
     Loading?: boolean;
-    Projects?: ProjectState[];
+    LoadingActiveEnterprise?: boolean;
+    LoadingEnterprises?: boolean;
+    LoadingFeed?: boolean;
+    Unleashed?: boolean;
     UserEnterpriseLookup?: string;
     constructor();
 }
-export declare class ProjectState {
-    ActionsSet?: {
-        [id: string]: DevOpsAction;
-    };
-    Description?: string;
-    Host?: string;
-    ID?: string;
-    Image?: string;
-    LCUs?: GitHubLowCodeUnit[];
-    Name?: string;
-    PreventInheritedApplications?: boolean;
-    Runs?: GitHubWorkflowRun[];
-}
 export declare class GitHubSetupState {
     BranchOptions?: GitHubBranch[];
     CreatingRepository?: boolean;
@@ -31,13 +29,6 @@ export declare class GitHubSetupState {
 export declare class GitHubBranch {
     Name?: string;
 }
-export declare class GitHubLowCodeUnit {
-    Branch?: string;
-    ID?: string;
-    Lookup?: string;
-    Organization?: string;
-    Repository?: string;
-}
 export declare class GitHubOrganization {
     Name?: string;
 }
@@ -55,29 +46,29 @@ export declare class GitHubWorkflowRun {
     Workflow?: string;
     UpdatedAt?: string;
 }
-export declare class DevOpsAction {
-    Details?: string;
-    ID?: string;
-    Name?: string;
-    Overwrite?: boolean;
-    Path?: string;
-    Template?: string;
+export declare class UnpackLowCodeUnitRequest {
+    ApplicationLookup?: string;
+    ApplicationName?: string;
+    Version?: string;
 }
 export declare class ProjectHostingDetails {
     HostingOptions?: ProjectHostingOption[];
     Loading?: boolean;
 }
 export declare class ProjectHostingOption {
+    ArtifactType?: string;
+    Description?: string;
+    Image?: string;
+    Inputs?: ProjectHostingOptionInput[];
     Lookup?: string;
     Name?: string;
+    Path?: string;
+    Templates?: string[];
 }
-export declare class EstablishProjectRequest {
-    Branch?: string;
-    BuildScript?: string;
-    HostingOption?: string;
-    Organization?: string;
-    OutputFolder?: string;
-    ProjectName?: string;
-    Repository?: string;
+export declare class ProjectHostingOptionInput {
+    DefaultValue?: string;
+    Hint?: string;
+    Lookup?: string;
+    Placeholder?: string;
+    Required?: boolean;
 }
-//# sourceMappingURL=applications-flow.state.d.ts.map

package/lowcodeunit-applications-flow-common.d.ts

@@ -1,17 +1,5 @@
 /**
  * Generated bundle index. Do not edit.
  */
+/// <amd-module name="@lowcodeunit/applications-flow-common" />
 export * from './lcu.api';
-export { BaseFormComponent as ɵk } from './lib/elements/base-form/base-form.component';
-export { DynamicTabsComponent as ɵb } from './lib/elements/dynamic-tabs/dynamic-tabs.component';
-export { FormCardComponent as ɵj } from './lib/elements/form-card/form-card.component';
-export { BuildsComponent as ɵh } from './lib/elements/projects/controls/builds/builds.component';
-export { HeaderComponent as ɵc } from './lib/elements/projects/controls/header/header.component';
-export { ProjectItemComponent as ɵg } from './lib/elements/projects/controls/project-item/project-item.component';
-export { ProjectTabsComponent as ɵd } from './lib/elements/projects/controls/project-tabs/project-tabs.component';
-export { RecentActivitiesComponent as ɵi } from './lib/elements/projects/controls/recent-activities/recent-activities.component';
-export { DomainsComponent as ɵf } from './lib/elements/projects/controls/tabs/domains/domains.component';
-export { BaseFormTestComponent as ɵl } from './lib/elements/projects/controls/tabs/general/forms/base-form-test/base-form-test.component';
-export { GeneralComponent as ɵe } from './lib/elements/projects/controls/tabs/general/general.component';
-export { ApplicationsFlowEventsService as ɵa } from './lib/services/applications-flow-events.service';
-//# sourceMappingURL=lowcodeunit-applications-flow-common.d.ts.map

package/package.json

@@ -1,19 +1,27 @@
 {
   "name": "@lowcodeunit/applications-flow-common",
-  "version": "0.0.2",
-  "peerDependencies": {
-    "@angular/common": "^10.2.4",
-    "@angular/core": "^10.2.4"
-  },
+  "version": "0.0.4",
   "dependencies": {
     "tslib": "^2.0.0"
   },
-  "main": "bundles/lowcodeunit-applications-flow-common.umd.js",
-  "module": "fesm2015/lowcodeunit-applications-flow-common.js",
-  "es2015": "fesm2015/lowcodeunit-applications-flow-common.js",
-  "esm2015": "esm2015/lowcodeunit-applications-flow-common.js",
-  "fesm2015": "fesm2015/lowcodeunit-applications-flow-common.js",
+  "module": "fesm2015/lowcodeunit-applications-flow-common.mjs",
+  "es2020": "fesm2020/lowcodeunit-applications-flow-common.mjs",
+  "esm2020": "esm2020/lowcodeunit-applications-flow-common.mjs",
+  "fesm2020": "fesm2020/lowcodeunit-applications-flow-common.mjs",
+  "fesm2015": "fesm2015/lowcodeunit-applications-flow-common.mjs",
   "typings": "lowcodeunit-applications-flow-common.d.ts",
-  "metadata": "lowcodeunit-applications-flow-common.metadata.json",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./lowcodeunit-applications-flow-common.d.ts",
+      "esm2020": "./esm2020/lowcodeunit-applications-flow-common.mjs",
+      "es2020": "./fesm2020/lowcodeunit-applications-flow-common.mjs",
+      "es2015": "./fesm2015/lowcodeunit-applications-flow-common.mjs",
+      "node": "./fesm2015/lowcodeunit-applications-flow-common.mjs",
+      "default": "./fesm2020/lowcodeunit-applications-flow-common.mjs"
+    }
+  },
   "sideEffects": false
-}
+}