@ngageoint/mage.web-core-lib 6.2.2

package/esm5/feed/feed.service.js

@@ -0,0 +1,108 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+var FeedService = /** @class */ (function () {
+    function FeedService(http) {
+        this.http = http;
+        // TODO: there is probably a better solution than maintaining this map here
+        this._feeds = new BehaviorSubject([]);
+        this.feeds = this._feeds.asObservable();
+        this._feedItems = new Map();
+    }
+    FeedService.prototype.feedItems = function (feedId) {
+        return this._feedItems.get(feedId).asObservable();
+    };
+    FeedService.prototype.fetchAllFeeds = function () {
+        return this.http.get('/api/feeds/');
+    };
+    FeedService.prototype.fetchFeed = function (feedId) {
+        return this.http.get("/api/feeds/" + feedId);
+    };
+    FeedService.prototype.fetchService = function (serviceId) {
+        return this.http.get("/api/feeds/services/" + serviceId);
+    };
+    FeedService.prototype.createService = function (service) {
+        return this.http.post("/api/feeds/services", service);
+    };
+    FeedService.prototype.fetchServices = function () {
+        return this.http.get("/api/feeds/services");
+    };
+    FeedService.prototype.fetchServiceFeeds = function (serviceId) {
+        return this.http.get("/api/feeds/services/" + serviceId + "/feeds");
+    };
+    FeedService.prototype.fetchServiceType = function (serviceTypeId) {
+        return this.http.get("/api/feeds/service_types/" + serviceTypeId);
+    };
+    FeedService.prototype.fetchTopics = function (serviceId) {
+        return this.http.get("/api/feeds/services/" + serviceId + "/topics");
+    };
+    FeedService.prototype.previewFeed = function (serviceId, topicId, feedSpec, opts) {
+        opts = opts || {};
+        var skipContentFetch = opts.skipContentFetch === true;
+        return this.http.post("/api/feeds/services/" + serviceId + "/topics/" + topicId + "/feed_preview?skip_content_fetch=" + skipContentFetch, { feed: feedSpec });
+    };
+    FeedService.prototype.fetchTopic = function (serviceId, topicId) {
+        return this.http.get("/api/feeds/services/" + serviceId + "/topics/" + topicId);
+    };
+    FeedService.prototype.fetchServiceTypes = function () {
+        return this.http.get("/api/feeds/service_types");
+    };
+    FeedService.prototype.createFeed = function (serviceId, topicId, feedConfiguration) {
+        return this.http.post("/api/feeds/services/" + serviceId + "/topics/" + topicId + "/feeds", feedConfiguration);
+    };
+    FeedService.prototype.updateFeed = function (feed) {
+        return this.http.put("/api/feeds/" + feed.id, feed);
+    };
+    FeedService.prototype.deleteFeed = function (feed) {
+        return this.http.delete("/api/feeds/" + feed.id, { responseType: 'text' });
+    };
+    FeedService.prototype.deleteService = function (service) {
+        console.log('delete');
+        return this.http.delete("/api/feeds/services/" + service.id, { responseType: 'text' });
+    };
+    FeedService.prototype.fetchFeeds = function (eventId) {
+        var _this = this;
+        var subject = new Subject();
+        this.http.get("/api/events/" + eventId + "/feeds").subscribe(function (feeds) {
+            feeds.map(function (feed) {
+                feed.id = feed.id.toString();
+                return feed;
+            });
+            feeds.forEach(function (feed) {
+                var feedItems = _this._feedItems.get(feed.id);
+                if (!feedItems) {
+                    feedItems = new BehaviorSubject([]);
+                    _this._feedItems.set(feed.id, feedItems);
+                }
+            });
+            subject.next(feeds);
+            _this._feeds.next(feeds);
+        });
+        return subject;
+    };
+    FeedService.prototype.fetchFeedItems = function (event, feed) {
+        var feedItems = this._feedItems.get(feed.id);
+        return this.http.post("/api/events/" + event.id + "/feeds/" + feed.id + "/content", {}).pipe(map(function (content) {
+            var features = content.items.features;
+            features.forEach(function (feature) {
+                feature.id = String(feature.id);
+                feature.properties = feature.properties || {};
+            });
+            feedItems.next(features);
+            return content;
+        }));
+    };
+    FeedService.ɵfac = function FeedService_Factory(t) { return new (t || FeedService)(i0.ɵɵinject(i1.HttpClient)); };
+    FeedService.ɵprov = i0.ɵɵdefineInjectable({ token: FeedService, factory: FeedService.ɵfac, providedIn: 'root' });
+    return FeedService;
+}());
+export { FeedService };
+/*@__PURE__*/ (function () { i0.ɵsetClassMetadata(FeedService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], function () { return [{ type: i1.HttpClient }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"feed.service.js","sourceRoot":"ng://@ngageoint/mage.web-core-lib/feed/","sources":["feed.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAE,eAAe,EAAc,OAAO,EAAE,MAAM,MAAM,CAAA;AAC3D,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAA;;;AAQpC;IAKE,qBAAoB,IAAgB;QAAhB,SAAI,GAAJ,IAAI,CAAY;QAEpC,2EAA2E;QACnE,WAAM,GAAG,IAAI,eAAe,CAAc,EAAE,CAAC,CAAC;QAC7C,UAAK,GAAG,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC;QAEpC,eAAU,GAAG,IAAI,GAAG,EAA2C,CAAC;IANhC,CAAC;IAOzC,+BAAS,GAAT,UAAU,MAAc;QACtB,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,YAAY,EAAE,CAAC;IACpD,CAAC;IAED,mCAAa,GAAb;QACE,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAc,aAAa,CAAC,CAAC;IACnD,CAAC;IAED,+BAAS,GAAT,UAAU,MAAc;QACtB,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAe,gBAAc,MAAQ,CAAC,CAAC;IAC7D,CAAC;IAED,kCAAY,GAAZ,UAAa,SAAiB;QAC5B,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAU,yBAAuB,SAAW,CAAC,CAAC;IACpE,CAAC;IAED,mCAAa,GAAb,UAAc,OAA6E;QACzF,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAU,qBAAqB,EAAE,OAAO,CAAC,CAAC;IACjE,CAAC;IAED,mCAAa,GAAb;QACE,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAiB,qBAAqB,CAAC,CAAC;IAC9D,CAAC;IAED,uCAAiB,GAAjB,UAAkB,SAAiB;QACjC,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAc,yBAAuB,SAAS,WAAQ,CAAC,CAAC;IAC9E,CAAC;IAED,sCAAgB,GAAhB,UAAiB,aAAqB;QACpC,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAc,8BAA4B,aAAe,CAAC,CAAC;IACjF,CAAC;IAED,iCAAW,GAAX,UAAY,SAAiB;QAC3B,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAmB,yBAAuB,SAAS,YAAS,CAAC,CAAC;IACpF,CAAC;IAED,iCAAW,GAAX,UAAY,SAAiB,EAAE,OAAe,EAAE,QAAsD,EAAE,IAAyB;QAC/H,IAAI,GAAG,IAAI,IAAI,EAAE,CAAA;QACjB,IAAM,gBAAgB,GAAY,IAAI,CAAC,gBAAgB,KAAK,IAAI,CAAA;QAChE,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CACnB,yBAAuB,SAAS,gBAAW,OAAO,yCAAoC,gBAAkB,EACxG,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;IACxB,CAAC;IAED,gCAAU,GAAV,UAAW,SAAiB,EAAE,OAAe;QAC3C,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAY,yBAAuB,SAAS,gBAAW,OAAS,CAAC,CAAC;IACxF,CAAC;IAED,uCAAiB,GAAjB;QACE,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAqB,0BAA0B,CAAC,CAAC;IACvE,CAAC;IAED,gCAAU,GAAV,UAAW,SAAiB,EAAE,OAAe,EAAE,iBAAsB;QACnE,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAe,yBAAuB,SAAS,gBAAW,OAAO,WAAQ,EAAE,iBAAiB,CAAC,CAAC;IACrH,CAAC;IAED,gCAAU,GAAV,UAAW,IAAsD;QAC/D,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAe,gBAAc,IAAI,CAAC,EAAI,EAAE,IAAI,CAAC,CAAC;IACpE,CAAC;IAED,gCAAU,GAAV,UAAW,IAAyB;QAClC,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,gBAAc,IAAI,CAAC,EAAI,EAAE,EAAC,YAAY,EAAE,MAAM,EAAC,CAAC,CAAC;IAC3E,CAAC;IAED,mCAAa,GAAb,UAAc,OAAgB;QAC5B,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAA;QACrB,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,yBAAuB,OAAO,CAAC,EAAI,EAAE,EAAE,YAAY,EAAE,MAAM,EAAE,CAAC,CAAC;IACzF,CAAC;IAED,gCAAU,GAAV,UAAW,OAAe;QAA1B,iBAqBC;QApBC,IAAM,OAAO,GAAG,IAAI,OAAO,EAAe,CAAC;QAC3C,IAAI,CAAC,IAAI,CAAC,GAAG,CAAc,iBAAe,OAAO,WAAQ,CAAC,CAAC,SAAS,CAAC,UAAA,KAAK;YACxE,KAAK,CAAC,GAAG,CAAC,UAAA,IAAI;gBACZ,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC;gBAC7B,OAAO,IAAI,CAAC;YACd,CAAC,CAAC,CAAC;YAEH,KAAK,CAAC,OAAO,CAAC,UAAA,IAAI;gBAChB,IAAI,SAAS,GAAG,KAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;gBAC7C,IAAI,CAAC,SAAS,EAAE;oBACd,SAAS,GAAG,IAAI,eAAe,CAAiB,EAAE,CAAC,CAAC;oBACpD,KAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,EAAE,SAAS,CAAC,CAAC;iBACzC;YACH,CAAC,CAAC,CAAA;YAEF,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACpB,KAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC1B,CAAC,CAAC,CAAC;QAEH,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,oCAAc,GAAd,UAAe,KAAU,EAAE,IAAU;QACnC,IAAM,SAAS,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;QAC9C,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAc,iBAAe,KAAK,CAAC,EAAE,eAAU,IAAI,CAAC,EAAE,aAAU,EAAE,EAAE,CAAC,CAAC,IAAI,CAC7F,GAAG,CAAC,UAAA,OAAO;YACT,IAAM,QAAQ,GAAG,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAA;YACvC,QAAQ,CAAC,OAAO,CAAC,UAAC,OAAsB;gBACtC,OAAO,CAAC,EAAE,GAAG,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;gBAC/B,OAAO,CAAC,UAAU,GAAG,OAAO,CAAC,UAAU,IAAI,EAAE,CAAA;YAC/C,CAAC,CAAC,CAAA;YACF,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;YACxB,OAAO,OAAO,CAAA;QAChB,CAAC,CAAC,CACH,CAAA;IACH,CAAC;0EAlHU,WAAW;uDAAX,WAAW,WAAX,WAAW,mBAFV,MAAM;sBAbpB;CAkIC,AAtHD,IAsHC;SAnHY,WAAW;kDAAX,WAAW;cAHvB,UAAU;eAAC;gBACV,UAAU,EAAE,MAAM;aACnB","sourcesContent":["import { HttpClient } from '@angular/common/http';\nimport { Injectable } from '@angular/core';\nimport { Feature } from 'geojson'\nimport { BehaviorSubject, Observable, Subject } from 'rxjs'\nimport { map } from 'rxjs/operators'\nimport { Feed, FeedContent, FeedExpanded, FeedPost, FeedPreview, FeedTopic, Service, ServiceType, StyledFeature } from './feed.model'\n\n\nexport interface FeedPreviewOptions {\n  skipContentFetch?: boolean\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class FeedService {\n\n  constructor(private http: HttpClient) { }\n\n  // TODO: there is probably a better solution than maintaining this map here\n  private _feeds = new BehaviorSubject<Array<Feed>>([]);\n  readonly feeds = this._feeds.asObservable();\n\n  private _feedItems = new Map<string, BehaviorSubject<Array<Feature>>>();\n  feedItems(feedId: string): Observable<Array<Feature>> {\n    return this._feedItems.get(feedId).asObservable();\n  }\n\n  fetchAllFeeds(): Observable<Array<Feed>> {\n    return this.http.get<Array<Feed>>('/api/feeds/');\n  }\n\n  fetchFeed(feedId: string): Observable<FeedExpanded> {\n    return this.http.get<FeedExpanded>(`/api/feeds/${feedId}`);\n  }\n\n  fetchService(serviceId: string): Observable<Service> {\n    return this.http.get<Service>(`/api/feeds/services/${serviceId}`);\n  }\n\n  createService(service: { title: string, summary?: string, serviceType: string, config: any}): Observable<Service> {\n    return this.http.post<Service>(`/api/feeds/services`, service);\n  }\n\n  fetchServices(): Observable<Array<Service>> {\n    return this.http.get<Array<Service>>(`/api/feeds/services`);\n  }\n\n  fetchServiceFeeds(serviceId: string): Observable<Array<Feed>> {\n    return this.http.get<Array<Feed>>(`/api/feeds/services/${serviceId}/feeds`);\n  }\n\n  fetchServiceType(serviceTypeId: string): Observable<ServiceType> {\n    return this.http.get<ServiceType>(`/api/feeds/service_types/${serviceTypeId}`);\n  }\n\n  fetchTopics(serviceId: string): Observable<Array<FeedTopic>> {\n    return this.http.get<Array<FeedTopic>>(`/api/feeds/services/${serviceId}/topics`);\n  }\n\n  previewFeed(serviceId: string, topicId: string, feedSpec: Partial<Omit<FeedPost, 'service' | 'topic'>>, opts?: FeedPreviewOptions): Observable<FeedPreview> {\n    opts = opts || {}\n    const skipContentFetch: boolean = opts.skipContentFetch === true\n    return this.http.post<FeedPreview>(\n      `/api/feeds/services/${serviceId}/topics/${topicId}/feed_preview?skip_content_fetch=${skipContentFetch}`,\n      { feed: feedSpec });\n  }\n\n  fetchTopic(serviceId: string, topicId: string): Observable<FeedTopic> {\n    return this.http.get<FeedTopic>(`/api/feeds/services/${serviceId}/topics/${topicId}`);\n  }\n\n  fetchServiceTypes(): Observable<Array<ServiceType>> {\n    return this.http.get<Array<ServiceType>>(`/api/feeds/service_types`);\n  }\n\n  createFeed(serviceId: string, topicId: string, feedConfiguration: any): Observable<FeedExpanded> {\n    return this.http.post<FeedExpanded>(`/api/feeds/services/${serviceId}/topics/${topicId}/feeds`, feedConfiguration);\n  }\n\n  updateFeed(feed: Partial<Omit<FeedPost, 'id'>> & Pick<Feed, 'id'>): Observable<FeedExpanded> {\n    return this.http.put<FeedExpanded>(`/api/feeds/${feed.id}`, feed);\n  }\n\n  deleteFeed(feed: Feed | FeedExpanded): Observable<{}> {\n    return this.http.delete(`/api/feeds/${feed.id}`, {responseType: 'text'});\n  }\n\n  deleteService(service: Service): Observable<{}> {\n    console.log('delete')\n    return this.http.delete(`/api/feeds/services/${service.id}`, { responseType: 'text' });\n  }\n\n  fetchFeeds(eventId: number): Observable<Array<Feed>> {\n    const subject = new Subject<Array<Feed>>();\n    this.http.get<Array<Feed>>(`/api/events/${eventId}/feeds`).subscribe(feeds => {\n      feeds.map(feed => {\n        feed.id = feed.id.toString();\n        return feed;\n      });\n\n      feeds.forEach(feed => {\n        let feedItems = this._feedItems.get(feed.id);\n        if (!feedItems) {\n          feedItems = new BehaviorSubject<Array<Feature>>([]);\n          this._feedItems.set(feed.id, feedItems);\n        }\n      })\n\n      subject.next(feeds);\n      this._feeds.next(feeds);\n    });\n\n    return subject;\n  }\n\n  fetchFeedItems(event: any, feed: Feed): Observable<FeedContent> {\n    const feedItems = this._feedItems.get(feed.id)\n    return this.http.post<FeedContent>(`/api/events/${event.id}/feeds/${feed.id}/content`, {}).pipe(\n      map(content => {\n        const features = content.items.features\n        features.forEach((feature: StyledFeature) => {\n          feature.id = String(feature.id)\n          feature.properties = feature.properties || {}\n        })\n        feedItems.next(features)\n        return content\n      })\n    )\n  }\n}\n"]}

package/esm5/feed/ngageoint-mage.web-core-lib-feed.js

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

package/esm5/feed/public-api.js

@@ -0,0 +1,2 @@
+export * from './feed.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZ2FnZW9pbnQvbWFnZS53ZWItY29yZS1saWIvZmVlZC8iLCJzb3VyY2VzIjpbInB1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsY0FBYyxnQkFBZ0IsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZmVlZC5tb2RlbCdcbmV4cG9ydCAqIGZyb20gJy4vZmVlZC5zZXJ2aWNlJyJdfQ==

package/esm5/mage-core-lib.module.js

@@ -0,0 +1,24 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import * as i0 from "@angular/core";
+var MageCoreLibModule = /** @class */ (function () {
+    function MageCoreLibModule() {
+    }
+    MageCoreLibModule.ɵmod = i0.ɵɵdefineNgModule({ type: MageCoreLibModule });
+    MageCoreLibModule.ɵinj = i0.ɵɵdefineInjector({ factory: function MageCoreLibModule_Factory(t) { return new (t || MageCoreLibModule)(); }, imports: [[
+                CommonModule
+            ]] });
+    return MageCoreLibModule;
+}());
+export { MageCoreLibModule };
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(MageCoreLibModule, { imports: [CommonModule] }); })();
+/*@__PURE__*/ (function () { i0.ɵsetClassMetadata(MageCoreLibModule, [{
+        type: NgModule,
+        args: [{
+                declarations: [],
+                imports: [
+                    CommonModule
+                ]
+            }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFnZS1jb3JlLWxpYi5tb2R1bGUuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmdhZ2VvaW50L21hZ2Uud2ViLWNvcmUtbGliLyIsInNvdXJjZXMiOlsibWFnZS1jb3JlLWxpYi5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7O0FBSS9DO0lBQUE7S0FNa0M7eURBQXJCLGlCQUFpQjtxSEFBakIsaUJBQWlCLGtCQUpuQjtnQkFDUCxZQUFZO2FBQ2I7NEJBVEg7Q0FXa0MsQUFObEMsSUFNa0M7U0FBckIsaUJBQWlCO3dGQUFqQixpQkFBaUIsY0FIMUIsWUFBWTtrREFHSCxpQkFBaUI7Y0FON0IsUUFBUTtlQUFDO2dCQUNSLFlBQVksRUFBRSxFQUFFO2dCQUNoQixPQUFPLEVBQUU7b0JBQ1AsWUFBWTtpQkFDYjthQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5cblxuXG5ATmdNb2R1bGUoe1xuICBkZWNsYXJhdGlvbnM6IFtdLFxuICBpbXBvcnRzOiBbXG4gICAgQ29tbW9uTW9kdWxlXG4gIF1cbn0pXG5leHBvcnQgY2xhc3MgTWFnZUNvcmVMaWJNb2R1bGUgeyB9XG4iXX0=

package/esm5/ngageoint-mage.web-core-lib.js

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

package/esm5/paging/ngageoint-mage.web-core-lib-paging.js

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

package/esm5/paging/paging.cdk-data-source.adapter.js

@@ -0,0 +1,60 @@
+import { __extends, __read, __spread } from "tslib";
+import { DataSource } from '@angular/cdk/collections';
+import { BehaviorSubject, Subscription } from 'rxjs';
+import { pageForItemIndex } from './paging.model';
+/**
+ * This class is an adaptation from the [Angular Material Guide](https://v8.material.angular.io/cdk/scrolling/overview), _"Specifying data" example_, also
+ * available on [StackBlitz](https://stackblitz.com/angular/mrbkjagnnra?file=src%2Fapp%2Fcdk-virtual-scroll-data-source-example.ts).
+ */
+var PagingDataSource = /** @class */ (function (_super) {
+    __extends(PagingDataSource, _super);
+    function PagingDataSource(pageSize, fetchPage) {
+        var _this = _super.call(this) || this;
+        _this.pageSize = pageSize;
+        _this.fetchPage = fetchPage;
+        _this.data = null;
+        _this.data$ = new BehaviorSubject([]);
+        _this.fetchedPages = new Set();
+        _this.subscription = new Subscription();
+        return _this;
+    }
+    PagingDataSource.prototype.connect = function (collectionViewer) {
+        var _this = this;
+        this.subscription.add(collectionViewer.viewChange.subscribe(function (range) {
+            var startPage = _this.pageForItemIndex(range.start);
+            var endPage = _this.pageForItemIndex(range.end - 1);
+            for (var page = startPage; page <= endPage; page++) {
+                _this.fetch(page);
+            }
+        }));
+        return this.data$;
+    };
+    PagingDataSource.prototype.disconnect = function () {
+        this.subscription.unsubscribe();
+    };
+    PagingDataSource.prototype.pageForItemIndex = function (index) {
+        return pageForItemIndex(index, this.pageSize);
+    };
+    PagingDataSource.prototype.fetch = function (pageIndex) {
+        var _this = this;
+        if (this.fetchedPages.has(pageIndex)) {
+            return;
+        }
+        this.fetchedPages.add(pageIndex);
+        var includeTotalCount = !this.data;
+        this.fetchPage({ pageSize: this.pageSize, pageIndex: pageIndex, includeTotalCount: includeTotalCount }).subscribe(function (page) {
+            var _a;
+            if (!_this.data) {
+                if (typeof (page.totalCount) !== 'number') {
+                    throw new Error('data is null and no total count is available to inform allocation');
+                }
+                _this.data = Array.from({ length: page.totalCount });
+            }
+            (_a = _this.data).splice.apply(_a, __spread([pageIndex * _this.pageSize, _this.pageSize], page.items));
+            _this.data$.next(_this.data);
+        });
+    };
+    return PagingDataSource;
+}(DataSource));
+export { PagingDataSource };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/paging/paging.model.js

@@ -0,0 +1,25 @@
+export var pageForItemIndex = function (itemIndex, pageSize) {
+    if (typeof pageSize === 'object') {
+        pageSize = pageSize.pageSize;
+    }
+    return Math.floor(itemIndex / pageSize);
+};
+/**
+ * Return the range of item indexes for the given page and page size.  The last
+ * end portion of the range is exclusive, so when indexing an array the last
+ * item of the page would have position `end - 1`.  This allows one to pass the
+ * values to `Array.slice()`.
+ * @param pageIndex
+ * @param pageSize
+ * @returns
+ */
+export var itemRangeOfPage = function (pageIndex, pageSize) {
+    if (typeof pageIndex === 'object') {
+        pageSize = pageIndex.pageSize;
+        pageIndex = pageIndex.pageIndex;
+    }
+    var start = pageSize * pageIndex;
+    var end = start + pageSize;
+    return [start, end];
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/paging/public-api.js

@@ -0,0 +1,3 @@
+export * from './paging.model';
+export * from './paging.cdk-data-source.adapter';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZ2FnZW9pbnQvbWFnZS53ZWItY29yZS1saWIvcGFnaW5nLyIsInNvdXJjZXMiOlsicHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGdCQUFnQixDQUFBO0FBQzlCLGNBQWMsa0NBQWtDLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3BhZ2luZy5tb2RlbCdcbmV4cG9ydCAqIGZyb20gJy4vcGFnaW5nLmNkay1kYXRhLXNvdXJjZS5hZGFwdGVyJyJdfQ==

package/esm5/plugin/ngageoint-mage.web-core-lib-plugin.js

@@ -0,0 +1,4 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmdhZ2VvaW50LW1hZ2Uud2ViLWNvcmUtbGliLXBsdWdpbi5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZ2FnZW9pbnQvbWFnZS53ZWItY29yZS1saWIvcGx1Z2luLyIsInNvdXJjZXMiOlsibmdhZ2VvaW50LW1hZ2Uud2ViLWNvcmUtbGliLXBsdWdpbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm5/plugin/plugin.model.js

@@ -0,0 +1 @@
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2luLm1vZGVsLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5nYWdlb2ludC9tYWdlLndlYi1jb3JlLWxpYi9wbHVnaW4vIiwic291cmNlcyI6WyJwbHVnaW4ubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFR5cGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJ1xuXG5leHBvcnQgaW50ZXJmYWNlIFBsdWdpbkhvb2tzIHtcbiAgbW9kdWxlOiBUeXBlPHVua25vd24+XG4gIGFkbWluVGFiPzoge1xuICAgIHRpdGxlOiBzdHJpbmdcbiAgICBpY29uPzogeyBwYXRoOiBzdHJpbmcgfSB8IHsgY2xhc3NOYW1lOiBzdHJpbmcgfSB8IG51bGwgfCB1bmRlZmluZWRcbiAgICB0YWJDb250ZW50Q29tcG9uZW50OiBUeXBlPHVua25vd24+XG4gIH1cbn0iXX0=

package/esm5/plugin/public-api.js

@@ -0,0 +1 @@
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZ2FnZW9pbnQvbWFnZS53ZWItY29yZS1saWIvcGx1Z2luLyIsInNvdXJjZXMiOlsicHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9wbHVnaW4ubW9kZWwnIl19

package/esm5/public-api.js

@@ -0,0 +1,5 @@
+/*
+ * Public API Surface of core-lib
+ */
+export * from './mage-core-lib.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZ2FnZW9pbnQvbWFnZS53ZWItY29yZS1saWIvIiwic291cmNlcyI6WyJwdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyx3QkFBd0IsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBQdWJsaWMgQVBJIFN1cmZhY2Ugb2YgY29yZS1saWJcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL21hZ2UtY29yZS1saWIubW9kdWxlJ1xuIl19

package/esm5/static-icon/ngageoint-mage.web-core-lib-static-icon.js

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

package/esm5/static-icon/public-api.js

@@ -0,0 +1,7 @@
+export * from './static-icon.model';
+export * from './static-icon.module';
+export * from './static-icon.service';
+export * from './static-icon-img/static-icon-img.component';
+export * from './static-icon-form-field/static-icon-form-field.component';
+export * from './static-icon-select/static-icon-select.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZ2FnZW9pbnQvbWFnZS53ZWItY29yZS1saWIvc3RhdGljLWljb24vIiwic291cmNlcyI6WyJwdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMscUJBQXFCLENBQUE7QUFDbkMsY0FBYyxzQkFBc0IsQ0FBQTtBQUNwQyxjQUFjLHVCQUF1QixDQUFBO0FBQ3JDLGNBQWMsNkNBQTZDLENBQUE7QUFDM0QsY0FBYywyREFBMkQsQ0FBQTtBQUN6RSxjQUFjLG1EQUFtRCxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9zdGF0aWMtaWNvbi5tb2RlbCdcbmV4cG9ydCAqIGZyb20gJy4vc3RhdGljLWljb24ubW9kdWxlJ1xuZXhwb3J0ICogZnJvbSAnLi9zdGF0aWMtaWNvbi5zZXJ2aWNlJ1xuZXhwb3J0ICogZnJvbSAnLi9zdGF0aWMtaWNvbi1pbWcvc3RhdGljLWljb24taW1nLmNvbXBvbmVudCdcbmV4cG9ydCAqIGZyb20gJy4vc3RhdGljLWljb24tZm9ybS1maWVsZC9zdGF0aWMtaWNvbi1mb3JtLWZpZWxkLmNvbXBvbmVudCdcbmV4cG9ydCAqIGZyb20gJy4vc3RhdGljLWljb24tc2VsZWN0L3N0YXRpYy1pY29uLXNlbGVjdC5jb21wb25lbnQnIl19

package/esm5/static-icon/static-icon-form-field/static-icon-form-field.component.js

@@ -0,0 +1,157 @@
+import { Component } from '@angular/core';
+import { FormControl, FormGroup, NG_VALIDATORS, NG_VALUE_ACCESSOR, Validators } from '@angular/forms';
+import * as i0 from "@angular/core";
+import * as i1 from "../static-icon.service";
+import * as i2 from "@angular/common/http";
+import * as i3 from "@angular/platform-browser";
+import * as i4 from "@angular/forms";
+import * as i5 from "@ngageoint/mage.web-core-lib/common";
+var StaticIconFormFieldComponent = /** @class */ (function () {
+    function StaticIconFormFieldComponent(iconService, httpClient, sanitizer) {
+        var _this = this;
+        this.iconService = iconService;
+        this.httpClient = httpClient;
+        this.sanitizer = sanitizer;
+        this.iconRef = null;
+        this.form = new FormGroup({
+            iconRefToken: new FormControl(null),
+            iconRefType: new FormControl(null, Validators.required)
+        });
+        this.onChange = function (iconRef) { };
+        this.onValidatorChange = function () { };
+        this.onTouched = function () { };
+        this.form.valueChanges.subscribe(function (x) {
+            _this.iconRef = iconRefForFormValue(x);
+            _this.onChange(_this.iconRef);
+        });
+    }
+    StaticIconFormFieldComponent.prototype.registerOnValidatorChange = function (fn) {
+        this.onValidatorChange = fn;
+    };
+    StaticIconFormFieldComponent.prototype.ngOnChanges = function (changes) { };
+    StaticIconFormFieldComponent.prototype.ngOnDestroy = function () { };
+    StaticIconFormFieldComponent.prototype.onSelectIcon = function () { };
+    StaticIconFormFieldComponent.prototype.writeValue = function (iconRef) {
+        this.iconRef = iconRef;
+        var formValue = formValueForIconRef(iconRef);
+        this.form.setValue(formValue, { emitEvent: false });
+        this.resolveIconRef();
+    };
+    StaticIconFormFieldComponent.prototype.registerOnChange = function (fn) {
+        this.onChange = fn;
+    };
+    StaticIconFormFieldComponent.prototype.registerOnTouched = function (fn) {
+        this.onTouched = fn;
+    };
+    StaticIconFormFieldComponent.prototype.setDisabledState = function (isDisabled) {
+        if (isDisabled) {
+            this.form.disable();
+        }
+        else {
+            this.form.enable();
+        }
+    };
+    StaticIconFormFieldComponent.prototype.validate = function (control) {
+        return this.form.errors;
+    };
+    StaticIconFormFieldComponent.prototype.resolveIconRef = function () {
+        var _this = this;
+        if (!this.iconRef) {
+            this.icon = null;
+            return;
+        }
+        this.iconService.fetchIconByReference(this.iconRef).subscribe(function (x) {
+            _this.icon = x;
+            if (!_this.icon) {
+                return;
+            }
+        });
+    };
+    StaticIconFormFieldComponent.ɵfac = function StaticIconFormFieldComponent_Factory(t) { return new (t || StaticIconFormFieldComponent)(i0.ɵɵdirectiveInject(i1.StaticIconService), i0.ɵɵdirectiveInject(i2.HttpClient), i0.ɵɵdirectiveInject(i3.DomSanitizer)); };
+    StaticIconFormFieldComponent.ɵcmp = i0.ɵɵdefineComponent({ type: StaticIconFormFieldComponent, selectors: [["mage-static-icon-form-field"]], features: [i0.ɵɵProvidersFeature([
+                {
+                    provide: NG_VALUE_ACCESSOR,
+                    multi: true,
+                    useExisting: StaticIconFormFieldComponent
+                },
+                {
+                    provide: NG_VALIDATORS,
+                    multi: true,
+                    useExisting: StaticIconFormFieldComponent
+                },
+            ]), i0.ɵɵNgOnChangesFeature], decls: 4, vars: 2, consts: [[3, "formGroup"], [1, "icon-image", 3, "src"], ["type", "hidden", "formControlName", "iconRefType"], ["type", "hidden", "formControlName", "iconRefToken"]], template: function StaticIconFormFieldComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelementStart(0, "div", 0);
+            i0.ɵɵelement(1, "mage-xhr-img", 1);
+            i0.ɵɵelement(2, "input", 2);
+            i0.ɵɵelement(3, "input", 3);
+            i0.ɵɵelementEnd();
+        } if (rf & 2) {
+            i0.ɵɵproperty("formGroup", ctx.form);
+            i0.ɵɵadvance(1);
+            i0.ɵɵproperty("src", ctx.icon == null ? null : ctx.icon.contentPath);
+        } }, directives: [i4.NgControlStatusGroup, i4.FormGroupDirective, i5.XhrImgComponent, i4.DefaultValueAccessor, i4.NgControlStatus, i4.FormControlName], styles: [".icon-image[_ngcontent-%COMP%]{display:block;height:3em;width:3em}"] });
+    return StaticIconFormFieldComponent;
+}());
+export { StaticIconFormFieldComponent };
+/*@__PURE__*/ (function () { i0.ɵsetClassMetadata(StaticIconFormFieldComponent, [{
+        type: Component,
+        args: [{
+                selector: 'mage-static-icon-form-field',
+                templateUrl: './static-icon-form-field.component.html',
+                styleUrls: ['./static-icon-form-field.component.scss'],
+                providers: [
+                    {
+                        provide: NG_VALUE_ACCESSOR,
+                        multi: true,
+                        useExisting: StaticIconFormFieldComponent
+                    },
+                    {
+                        provide: NG_VALIDATORS,
+                        multi: true,
+                        useExisting: StaticIconFormFieldComponent
+                    },
+                ]
+            }]
+    }], function () { return [{ type: i1.StaticIconService }, { type: i2.HttpClient }, { type: i3.DomSanitizer }]; }, null); })();
+var IconRefType;
+(function (IconRefType) {
+    IconRefType["Registered"] = "id";
+    IconRefType["SourceUrl"] = "sourceUrl";
+})(IconRefType || (IconRefType = {}));
+function iconRefForFormValue(x) {
+    var _a, _b;
+    if (!x.iconRefType) {
+        return null;
+    }
+    switch (x.iconRefType) {
+        case IconRefType.Registered:
+            return _a = {}, _a[IconRefType.Registered] = x.iconRefToken, _a;
+        case IconRefType.SourceUrl:
+            return _b = {}, _b[IconRefType.SourceUrl] = x.iconRefToken, _b;
+        default:
+            throw new Error('invalid icon ref type: ' + x.iconRefToken);
+    }
+}
+function formValueForIconRef(x) {
+    if (!x) {
+        return {
+            iconRefType: null,
+            iconRefToken: null
+        };
+    }
+    var iconRefType = null;
+    var iconRefToken = null;
+    if (x.hasOwnProperty(IconRefType.Registered)) {
+        iconRefType = IconRefType.Registered || null;
+        iconRefToken = x[IconRefType.Registered] || null;
+    }
+    else if (x.hasOwnProperty(IconRefType.SourceUrl)) {
+        iconRefType = IconRefType.SourceUrl || null;
+        iconRefToken = x[IconRefType.SourceUrl] || null;
+    }
+    return {
+        iconRefType: iconRefType,
+        iconRefToken: iconRefToken
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"static-icon-form-field.component.js","sourceRoot":"ng://@ngageoint/mage.web-core-lib/static-icon/","sources":["static-icon-form-field/static-icon-form-field.component.ts","static-icon-form-field/static-icon-form-field.component.html"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http'\nimport { Component, OnChanges, OnDestroy, SimpleChanges } from '@angular/core'\nimport { AbstractControl, ControlValueAccessor, FormControl, FormGroup, NG_VALIDATORS, NG_VALUE_ACCESSOR, ValidationErrors, Validator, Validators } from '@angular/forms'\nimport { DomSanitizer } from '@angular/platform-browser'\nimport { StaticIcon, StaticIconReference } from '../static-icon.model'\nimport { StaticIconService } from '../static-icon.service'\n\n\n@Component({\n  selector: 'mage-static-icon-form-field',\n  templateUrl: './static-icon-form-field.component.html',\n  styleUrls: ['./static-icon-form-field.component.scss'],\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      multi: true,\n      useExisting: StaticIconFormFieldComponent\n    },\n    {\n      provide: NG_VALIDATORS,\n      multi: true,\n      useExisting: StaticIconFormFieldComponent\n    },\n  ]\n})\nexport class StaticIconFormFieldComponent implements OnChanges, OnDestroy, ControlValueAccessor, Validator {\n\n  iconRef: StaticIconReference = null\n\n  form: FormGroup = new FormGroup({\n    iconRefToken: new FormControl(null),\n    iconRefType: new FormControl(null, Validators.required)\n  })\n  icon: StaticIcon | null\n\n  private onChange: (iconRef: StaticIconReference) => void = (iconRef: StaticIconReference) => {}\n  private onValidatorChange: () => void = () => {}\n  private onTouched: () => void = () => {}\n\n  constructor(private iconService: StaticIconService, private httpClient: HttpClient, private sanitizer: DomSanitizer) {\n    this.form.valueChanges.subscribe((x: IconRefFormValue) => {\n      this.iconRef = iconRefForFormValue(x)\n      this.onChange(this.iconRef)\n    })\n  }\n\n  registerOnValidatorChange?(fn: () => void): void {\n    this.onValidatorChange = fn\n  }\n\n  ngOnChanges(changes: SimpleChanges) { }\n\n  ngOnDestroy() { }\n\n  onSelectIcon() { }\n\n  writeValue(iconRef: StaticIconReference): void {\n    this.iconRef = iconRef\n    const formValue = formValueForIconRef(iconRef)\n    this.form.setValue(formValue, { emitEvent: false })\n    this.resolveIconRef()\n  }\n\n  registerOnChange(fn: (x: StaticIconReference | null) => void): void {\n    this.onChange = fn\n  }\n\n  registerOnTouched(fn: () => void): void {\n    this.onTouched = fn\n  }\n\n  setDisabledState?(isDisabled: boolean): void {\n    if (isDisabled) {\n      this.form.disable()\n    }\n    else {\n      this.form.enable()\n    }\n  }\n\n  validate(control: AbstractControl): ValidationErrors {\n    return this.form.errors\n  }\n\n  private resolveIconRef() {\n    if (!this.iconRef) {\n      this.icon = null\n      return\n    }\n    this.iconService.fetchIconByReference(this.iconRef).subscribe(x => {\n      this.icon = x\n      if (!this.icon) {\n        return\n      }\n    })\n  }\n}\n\nenum IconRefType {\n  Registered = 'id',\n  SourceUrl = 'sourceUrl'\n}\n\ntype IconRefFormValue = {\n  iconRefToken: string | null\n  iconRefType: IconRefType | null\n}\n\nfunction iconRefForFormValue(x: IconRefFormValue): StaticIconReference | null {\n  if (!x.iconRefType) {\n    return null\n  }\n  switch (x.iconRefType) {\n    case IconRefType.Registered:\n      return { [IconRefType.Registered]: x.iconRefToken }\n    case IconRefType.SourceUrl:\n      return { [IconRefType.SourceUrl]: x.iconRefToken }\n    default:\n      throw new Error('invalid icon ref type: ' + x.iconRefToken)\n  }\n}\n\nfunction formValueForIconRef(x: StaticIconReference | null): IconRefFormValue {\n  if (!x) {\n    return {\n      iconRefType: null,\n      iconRefToken: null\n    }\n  }\n  let iconRefType: IconRefType | null = null\n  let iconRefToken: string | null = null\n  if (x.hasOwnProperty(IconRefType.Registered)) {\n    iconRefType = IconRefType.Registered || null\n    iconRefToken = x[IconRefType.Registered] || null\n  }\n  else if (x.hasOwnProperty(IconRefType.SourceUrl)) {\n    iconRefType = IconRefType.SourceUrl || null\n    iconRefToken = x[IconRefType.SourceUrl] || null\n  }\n  return {\n    iconRefType,\n    iconRefToken\n  }\n}\n","<div [formGroup]=\"form\">\n  <mage-xhr-img class=\"icon-image\" [src]=\"icon?.contentPath\"></mage-xhr-img>\n  <input type=\"hidden\" formControlName=\"iconRefType\"/>\n  <input type=\"hidden\" formControlName=\"iconRefToken\"/>\n</div>"]}

package/esm5/static-icon/static-icon-img/static-icon-img.component.js

@@ -0,0 +1,38 @@
+import { Component, Input } from '@angular/core';
+import { contentPathOfIcon } from '../static-icon.model';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngageoint/mage.web-core-lib/common";
+var StaticIconImgComponent = /** @class */ (function () {
+    function StaticIconImgComponent() {
+    }
+    StaticIconImgComponent.prototype.ngOnInit = function () {
+    };
+    StaticIconImgComponent.prototype.ngOnChanges = function (changes) {
+        if (changes.iconRef) {
+            if (this.iconRef) {
+                this.iconPath = contentPathOfIcon(this.iconRef);
+            }
+            else {
+                this.iconPath = null;
+            }
+        }
+    };
+    StaticIconImgComponent.ɵfac = function StaticIconImgComponent_Factory(t) { return new (t || StaticIconImgComponent)(); };
+    StaticIconImgComponent.ɵcmp = i0.ɵɵdefineComponent({ type: StaticIconImgComponent, selectors: [["mage-static-icon-img"]], inputs: { iconRef: "iconRef" }, features: [i0.ɵɵNgOnChangesFeature], decls: 1, vars: 1, consts: [[3, "src"]], template: function StaticIconImgComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelement(0, "mage-xhr-img", 0);
+        } if (rf & 2) {
+            i0.ɵɵproperty("src", ctx.iconPath);
+        } }, directives: [i1.XhrImgComponent], encapsulation: 2 });
+    return StaticIconImgComponent;
+}());
+export { StaticIconImgComponent };
+/*@__PURE__*/ (function () { i0.ɵsetClassMetadata(StaticIconImgComponent, [{
+        type: Component,
+        args: [{
+                selector: 'mage-static-icon-img',
+                template: "<mage-xhr-img [src]=\"iconPath\"></mage-xhr-img>",
+            }]
+    }], function () { return []; }, { iconRef: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/static-icon/static-icon-select/static-icon-select.component.js

@@ -0,0 +1,65 @@
+import { Component } from '@angular/core';
+import { PagingDataSource } from '@ngageoint/mage.web-core-lib/paging';
+import * as i0 from "@angular/core";
+import * as i1 from "../static-icon.service";
+import * as i2 from "@angular/cdk/scrolling";
+import * as i3 from "@angular/material/card";
+function StaticIconSelectComponent_mat_card_2_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "mat-card", 3);
+    i0.ɵɵelementStart(1, "mat-card-header");
+    i0.ɵɵelementStart(2, "mat-card-title");
+    i0.ɵɵtext(3);
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementEnd();
+    i0.ɵɵelement(4, "img", 4);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    var icon_r1 = ctx.$implicit;
+    i0.ɵɵadvance(3);
+    i0.ɵɵtextInterpolate(icon_r1.title);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("src", icon_r1.path, i0.ɵɵsanitizeUrl);
+} }
+var StaticIconSelectComponent = /** @class */ (function () {
+    function StaticIconSelectComponent(iconService) {
+        var _this = this;
+        this.iconService = iconService;
+        this.icons = null;
+        this.dataSource = new PagingDataSource(250, function (paging) {
+            return _this.iconService.fetchIcons(paging);
+        });
+    }
+    StaticIconSelectComponent.prototype.ngOnInit = function () {
+        var _this = this;
+        this.iconService.fetchIcons().subscribe(function (x) {
+            _this.icons = x.items;
+        });
+    };
+    StaticIconSelectComponent.prototype.onBrowseForUploadIcon = function () {
+        throw new Error('unimplemented');
+    };
+    StaticIconSelectComponent.ɵfac = function StaticIconSelectComponent_Factory(t) { return new (t || StaticIconSelectComponent)(i0.ɵɵdirectiveInject(i1.StaticIconService)); };
+    StaticIconSelectComponent.ɵcmp = i0.ɵɵdefineComponent({ type: StaticIconSelectComponent, selectors: [["static-icon-select"]], decls: 3, vars: 2, consts: [[1, "icon-select"], [3, "itemSize"], ["class", "icon-select-item", 4, "cdkVirtualFor", "cdkVirtualForOf"], [1, "icon-select-item"], ["mat-card-img", "", 3, "src"]], template: function StaticIconSelectComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelementStart(0, "div", 0);
+            i0.ɵɵelementStart(1, "cdk-virtual-scroll-viewport", 1);
+            i0.ɵɵtemplate(2, StaticIconSelectComponent_mat_card_2_Template, 5, 2, "mat-card", 2);
+            i0.ɵɵelementEnd();
+            i0.ɵɵelementEnd();
+        } if (rf & 2) {
+            i0.ɵɵadvance(1);
+            i0.ɵɵproperty("itemSize", 40);
+            i0.ɵɵadvance(1);
+            i0.ɵɵproperty("cdkVirtualForOf", ctx.icons);
+        } }, directives: [i2.CdkVirtualScrollViewport, i2.CdkFixedSizeVirtualScroll, i2.CdkVirtualForOf, i3.MatCard, i3.MatCardHeader, i3.MatCardTitle], styles: ["virtual-scroll[_ngcontent-%COMP%]{display:grid;grid-template-columns:repeat(3,33%);grid-auto-rows:min-content;grid-gap:0;justify-content:center;gap:0}"] });
+    return StaticIconSelectComponent;
+}());
+export { StaticIconSelectComponent };
+/*@__PURE__*/ (function () { i0.ɵsetClassMetadata(StaticIconSelectComponent, [{
+        type: Component,
+        args: [{
+                selector: 'static-icon-select',
+                templateUrl: './static-icon-select.component.html',
+                styleUrls: ['./static-icon-select.component.scss']
+            }]
+    }], function () { return [{ type: i1.StaticIconService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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