@hestia-earth/ui-components 0.0.1

package/search/search.service.d.ts

@@ -0,0 +1,129 @@
+import { HttpClient } from '@angular/common/http';
+import { JSONLD, NodeType, ICycleJSONLD, ISourceJSONLD, ITermJSONLD, Source, IImpactAssessmentJSONLD } from '@hestia-earth/schema';
+import { HeCommonService } from '../common/common.service';
+import { searchableType } from './search.model';
+import * as i0 from "@angular/core";
+export declare type searchResult = ICycleJSONLD | ISourceJSONLD | IImpactAssessmentJSONLD | ITermJSONLD;
+export declare type sortOrders = 'asc' | 'desc';
+interface ISearchParamSort {
+    [key: string]: sortOrders;
+}
+interface ISearchScript {
+    _script: {
+        type?: string;
+        order?: sortOrders;
+        script: string;
+    };
+}
+export interface ISearchParams {
+    limit?: number;
+    offset?: number;
+    fields?: string[];
+    sort?: ISearchParamSort[] | ISearchScript;
+    query?: any;
+}
+export interface ISearchResultExtended {
+    _score: number;
+    createdAt: string;
+    location?: {
+        lat: number;
+        lon: number;
+    };
+    properties?: string[];
+    expanded?: boolean;
+    extended?: boolean;
+    pinned?: boolean;
+    loading?: boolean;
+    selected?: boolean;
+    inputsCount?: number;
+    emissionsCount?: number;
+    productsCount?: number;
+}
+export interface ISearchResults<C extends JSONLD<T>, T extends NodeType = searchableType> {
+    /**
+     * Amount of time the query took
+     */
+    time: number;
+    /**
+     * Numnber of results
+     */
+    count: number;
+    results: (C & ISearchResultExtended)[];
+}
+export declare const MAX_RESULTS = 10000;
+export declare const suggestMatchQuery: (query: string) => (Readonly<{
+    match: {
+        [x: string]: {
+            boost?: number | undefined;
+            query: any;
+        };
+    };
+}> | Readonly<{
+    multi_match: {
+        analyzer?: "standard" | undefined;
+        boost?: number | undefined;
+        query: string;
+        fields: string[];
+        type: "best_fields" | "most_fields" | "cross_fields" | "phrase" | "phrase_prefix" | "bool_prefix";
+    };
+}> | Readonly<{
+    match_phrase_prefix: {
+        nameSearchAsYouType: {
+            query: string;
+            boost: number;
+        };
+    };
+}>)[];
+export declare const suggestQuery: <T extends NodeType = searchableType>(query: string, type?: T | undefined, extraQueries?: any[]) => {
+    bool: {
+        must: any[];
+        should: {
+            bool: {
+                must: Readonly<{
+                    match: {
+                        '@type': string;
+                    };
+                }>[];
+                should: (Readonly<{
+                    match: {
+                        [x: string]: {
+                            boost?: number | undefined;
+                            query: any;
+                        };
+                    };
+                }> | Readonly<{
+                    multi_match: {
+                        analyzer?: "standard" | undefined;
+                        boost?: number | undefined;
+                        query: string;
+                        fields: string[];
+                        type: "best_fields" | "most_fields" | "cross_fields" | "phrase" | "phrase_prefix" | "bool_prefix";
+                    };
+                }> | Readonly<{
+                    match_phrase_prefix: {
+                        nameSearchAsYouType: {
+                            query: string;
+                            boost: number;
+                        };
+                    };
+                }>)[];
+                minimum_should_match: number;
+            };
+        }[];
+        minimum_should_match: number;
+    };
+};
+export declare class HeSearchService {
+    private http;
+    private commonService;
+    constructor(http: HttpClient, commonService: HeCommonService);
+    search<C extends JSONLD<T>, T extends NodeType = searchableType>(params: ISearchParams): Promise<ISearchResults<C, T>>;
+    count(params?: {}): Promise<number>;
+    get$<C extends JSONLD<T>, T extends NodeType>(type: T, id: string): import("rxjs").Observable<C & ISearchResultExtended>;
+    get<C extends JSONLD<T>, T extends NodeType>(type: T, id: string): Promise<C & ISearchResultExtended>;
+    suggest<C extends JSONLD<T>, T extends NodeType = searchableType>(term: string, type?: T, extraQueries?: any[], fullQuery?: any, limit?: number, includes?: string[]): import("rxjs").Observable<Omit<C & ISearchResultExtended, "_score">[]>;
+    suggestSource(term: string, limit?: number, fields?: string[], includes?: string[]): import("rxjs").Observable<Partial<Source>[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeSearchService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HeSearchService>;
+}
+export {};

package/sites/public-api.d.ts

@@ -0,0 +1,5 @@
+export * from './sites.model';
+export * from './sites.module';
+export { SitesMapsComponent } from './sites-maps/sites-maps.component';
+export { SitesMeasurementsComponent } from './sites-measurements/sites-measurements.component';
+export { SitesMeasurementsLogsComponent } from './sites-measurements-logs/sites-measurements-logs.component';

package/sites/sites-maps/sites-maps.component.d.ts

@@ -0,0 +1,35 @@
+import { AfterViewInit, OnInit } from '@angular/core';
+import { JSONLD, NodeType } from '@hestia-earth/schema';
+import { HeNodeService } from '../../node/node.service';
+import * as i0 from "@angular/core";
+export declare class SitesMapsComponent<C extends JSONLD<T>, T extends NodeType> implements OnInit, AfterViewInit {
+    private nodeService;
+    loaded: boolean;
+    private map?;
+    private loadPolygons;
+    private sites;
+    private nodes;
+    center: {
+        lat: number;
+        lng: number;
+    };
+    zoom: number;
+    showNotice: boolean;
+    googleLoaded: boolean;
+    showNoLocation: boolean;
+    constructor(nodeService: HeNodeService);
+    ngOnInit(): void;
+    ngAfterViewInit(): false | Promise<void | null>;
+    private loadData;
+    private addMarkers;
+    private addTermsPolygons;
+    private centerMarker;
+    private centerPolygons;
+    private addSiteMarkers;
+    private loadSite;
+    private siteData;
+    private getSites;
+    private termPolygons;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SitesMapsComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SitesMapsComponent<any, any>, "he-sites-maps", never, { "loadPolygons": "loadPolygons"; "sites": "sites"; "nodes": "nodes"; "center": "center"; "zoom": "zoom"; "showNotice": "showNotice"; }, {}, never, never>;
+}

package/sites/sites-measurements/sites-measurements.component.d.ts

@@ -0,0 +1,31 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import { DataState } from '@hestia-earth/api';
+import { ISiteJSONLD, Measurement } from '@hestia-earth/schema';
+import { IGroupedKeys } from '../../common/utils';
+import * as i0 from "@angular/core";
+declare enum View {
+    table = "table",
+    logs = "logs"
+}
+export declare class SitesMeasurementsComponent implements OnChanges {
+    originalValues: ISiteJSONLD[];
+    sites: ISiteJSONLD[];
+    dataState?: DataState;
+    showDownload: boolean;
+    View: typeof View;
+    selectedView: View;
+    maxAreaSize: number;
+    siteTooBig: ({ area }: ISiteJSONLD) => boolean | 0 | undefined;
+    defaultLabel: (node?: any) => any;
+    measurementValue: ({ value, depthLower, depthUpper }: import("../../common/utils").IGroupedNode<Measurement>) => number;
+    measurements: IGroupedKeys<Measurement>[];
+    ngOnChanges(changes: SimpleChanges): void;
+    trackById(_index: number, item: ISiteJSONLD): string;
+    get isOriginal(): boolean;
+    private update;
+    togglePopover(popover: any, context: any): any;
+    get showAreaTooBig(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SitesMeasurementsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SitesMeasurementsComponent, "he-sites-measurements", never, { "originalValues": "originalValues"; "sites": "sites"; "dataState": "dataState"; }, {}, never, never>;
+}
+export {};

package/sites/sites-measurements-logs/sites-measurements-logs.component.d.ts

@@ -0,0 +1,23 @@
+import { OnInit } from '@angular/core';
+import { ISiteJSONLD, ITermJSONLD, Measurement, NodeType } from '@hestia-earth/schema';
+import { HeSearchService } from '../../search/search.service';
+import { HeNodeService } from '../../node/node.service';
+import * as i0 from "@angular/core";
+export declare class SitesMeasurementsLogsComponent implements OnInit {
+    private searchService;
+    private nodeService;
+    site?: ISiteJSONLD;
+    originalValues: Measurement[];
+    recalculatedValues: Measurement[];
+    loading: boolean;
+    NodeType: typeof NodeType;
+    logsUrl?: string;
+    logs: any;
+    models: ITermJSONLD[];
+    measurements: ITermJSONLD[];
+    constructor(searchService: HeSearchService, nodeService: HeNodeService);
+    ngOnInit(): Promise<void>;
+    private get node();
+    static ɵfac: i0.ɵɵFactoryDeclaration<SitesMeasurementsLogsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SitesMeasurementsLogsComponent, "he-sites-measurements-logs", never, { "site": "site"; "originalValues": "originalValues"; "recalculatedValues": "recalculatedValues"; }, {}, never, never>;
+}

package/sites/sites.model.d.ts

@@ -0,0 +1,10 @@
+import { NodeType, ISiteJSONLD, Measurement } from '@hestia-earth/schema';
+import { IGroupedNode } from '../common/utils';
+export interface ISiteJSONLDExtended extends ISiteJSONLD {
+    related: {
+        [type in NodeType]?: string[];
+    };
+}
+export declare const maxAreaSize = 5000;
+export declare const siteTooBig: ({ area }: ISiteJSONLD) => boolean | 0 | undefined;
+export declare const measurementValue: ({ value, depthLower, depthUpper }: IGroupedNode<Measurement>) => number;

package/sites/sites.module.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./sites-maps/sites-maps.component";
+import * as i2 from "./sites-measurements/sites-measurements.component";
+import * as i3 from "./sites-measurements-logs/sites-measurements-logs.component";
+import * as i4 from "@angular/common";
+import * as i5 from "@angular/forms";
+import * as i6 from "../common/common.module";
+import * as i7 from "../node/node.module";
+export declare class HeSitesModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeSitesModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HeSitesModule, [typeof i1.SitesMapsComponent, typeof i2.SitesMeasurementsComponent, typeof i3.SitesMeasurementsLogsComponent], [typeof i4.CommonModule, typeof i5.ReactiveFormsModule, typeof i6.HeCommonModule, typeof i7.HeNodeModule], [typeof i1.SitesMapsComponent, typeof i2.SitesMeasurementsComponent, typeof i3.SitesMeasurementsLogsComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HeSitesModule>;
+}

package/styles.scss

@@ -0,0 +1,197 @@
+@import '~@hestia-earth/ui-framework/src/styles';
+
+// JSON Diff Patch
+@import '~jsondiffpatch/dist/formatters-styles/html.css';
+
+.jsondiffpatch-delta {
+  max-width: 100%;
+}
+
+// --- Bootstrap
+
+ngb-typeahead-window.dropdown-menu {
+  background-color: $dropdown-content-background-color;
+  border-radius: $dropdown-content-radius;
+  box-shadow: $dropdown-content-shadow;
+  margin-top: 2px;
+  max-height: 360px;
+  min-width: 300px;
+  overflow-y: auto;
+  padding-bottom: $dropdown-content-padding-bottom;
+  padding-top: $dropdown-content-padding-top;
+  width: 100%;
+
+  .dropdown-item {
+    border: 0;
+    cursor: pointer;
+
+    &:hover {
+      background-color: $dropdown-item-hover-background-color;
+      color: $dropdown-item-hover-color;
+    }
+
+    &.active {
+      background-color: $dropdown-item-active-background-color;
+      color: $dropdown-item-active-color;
+    }
+
+    > * {
+      display: inline-block;
+      vertical-align: middle;
+    }
+  }
+}
+
+ngb-highlight {
+  display: inline-block;
+  overflow: hidden;
+  text-align: left;
+  text-overflow: ellipsis;
+  width: 100%;
+  white-space: nowrap;
+}
+
+ngb-tooltip-window {
+  background-color: $black;
+  border-radius: $tag-radius;
+  color: $white;
+  font-size: .75rem;
+  padding: .25rem;
+  z-index: 1050;
+}
+
+ngb-popover-window {
+  font-size: .75rem;
+  max-width: 50vw;
+  z-index: 1060;
+
+  .arrow {
+    margin: 0 !important;
+  }
+
+  .popover-header {
+    background-color: $light;
+    border-bottom: 1px solid #ebebeb;
+    border-top-left-radius: $tag-radius;
+    border-top-right-radius: $tag-radius;
+    font-size: 1rem;
+    margin-bottom: 0;
+    padding: .5rem .75rem;
+
+    + .popover-body {
+      border-top-left-radius: 0;
+      border-top-right-radius: 0;
+    }
+  }
+
+  .popover-body {
+    background-color: $black;
+    border-radius: $tag-radius;
+    color: $white;
+    padding: .5rem .75rem;
+  }
+}
+
+// Hestia
+
+.data-table-container {
+  max-height: 320px;
+  overflow-y: auto;
+}
+
+table.data-table {
+  min-width: 100%;
+
+  th {
+    word-break: break-word;
+  }
+
+  td,
+  th {
+    font-size: 12px;
+    max-width: 100px;
+    min-width: 80px;
+
+    span:first-child {
+      display: inline-block;
+      max-width: 100%;
+    }
+
+    &:nth-child(1) {
+      min-width: 200px;
+      width: 200px;
+    }
+
+    &.width-auto {
+      max-width: auto !important;
+    }
+
+    &:not(.width-auto) {
+      text-align: center;
+    }
+  }
+
+  &.has-children-1 {
+    td,
+    th {
+      &:nth-child(n+2) {
+        max-width: auto;
+      }
+    }
+  }
+
+  &.has-children-2 {
+    td,
+    th {
+      &:nth-child(n+2) {
+        max-width: 50%;
+      }
+    }
+  }
+
+  &.has-children-3 {
+    td,
+    th {
+      &:nth-child(n+2) {
+        max-width: 40%;
+      }
+    }
+  }
+
+  &.has-children-4 {
+    td,
+    th {
+      &:nth-child(n+2) {
+        max-width: 30%;
+      }
+    }
+  }
+
+  &.has-children-5 {
+    td,
+    th {
+      &:nth-child(n+2) {
+        max-width: 20%;
+      }
+    }
+  }
+}
+
+.copy-clipboard {
+  position: absolute;
+  right: 4px;
+  top: 4px;
+}
+
+.trigger-popover {
+  > span:first-child {
+    cursor: help !important;
+    text-decoration-style: dotted;
+    text-decoration-line: underline;
+    text-decoration-thickness: from-font;
+  }
+}
+
+.is-normal {
+  white-space: normal;
+}

package/terms/public-api.d.ts

@@ -0,0 +1 @@
+export * from './terms.model';

package/terms/terms.model.d.ts

@@ -0,0 +1,21 @@
+import { Term, ITermJSONLD, TermTermType } from '@hestia-earth/schema';
+export declare const termProperties: (term: Term | ITermJSONLD) => string[];
+export declare const findPropertyById: ({ defaultProperties }: Term | ITermJSONLD, key: keyof ITermJSONLD) => import("@hestia-earth/schema").Property | undefined;
+export declare const termLocationName: ({ gadmFullName }: Term | ITermJSONLD) => {
+    name: string;
+};
+export declare const termLocation: ({ latitude, longitude }: Term | ITermJSONLD) => {
+    lat: number;
+    lng: number;
+};
+export declare const termTypeLabel: (type?: TermTermType | string) => string;
+export interface ITermTypeElem {
+    label?: string;
+    termType: TermTermType | string;
+    children?: ITermTypeElem[];
+    visible?: boolean;
+    count?: number;
+}
+export declare const termTypeGroups: ITermTypeElem[];
+export declare const termChildToParent: (termType: string) => ITermTypeElem;
+export declare const sortOrder: TermTermType[];

package/users/public-api.d.ts

@@ -0,0 +1 @@
+export * from './users.service';

package/users/users.service.d.ts

@@ -0,0 +1,7 @@
+import { User } from '@hestia-earth/api';
+import * as i0 from "@angular/core";
+export declare class HeUsersService {
+    get loggedInUser(): Promise<User>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeUsersService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HeUsersService>;
+}