@solidev/data 0.0.1-alpha.0

package/esm2020/lib/modellist/model-list.service.mjs

@@ -0,0 +1,135 @@
+import { Injectable } from '@angular/core';
+import { combineLatest, debounceTime, NEVER, of, share, Subject, takeUntil, } from 'rxjs';
+import { switchMap } from 'rxjs/operators';
+import { ModelListFields } from './model-list-fields/model-list-fields';
+import { ModelListPaginator } from './model-list-paginator/model-list-paginator';
+import { ModelListSorter } from './model-list-sorter/model-list-sorter';
+import { ModelListFilters } from './model-list-filters/model-list-filters';
+import * as i0 from "@angular/core";
+export class ModelList {
+    constructor(name) {
+        this.started = false;
+        this.name = name;
+    }
+    get results() {
+        if (!this._results) {
+            this._results = this.queryset.results.pipe(
+            // tap(() => console.log('RESULTS')),
+            share(), takeUntil(this.unsubscribe || NEVER));
+        }
+        return this._results;
+    }
+    get meta() {
+        if (!this._meta) {
+            this._meta = this.queryset.meta.pipe(
+            // tap(() => console.log('META')),
+            share(), takeUntil(this.unsubscribe || NEVER));
+        }
+        return this._meta;
+    }
+    get loading() {
+        if (!this._loading) {
+            this._loading = this.queryset.loading.pipe(
+            // tap(() => console.log('LOADING')),
+            share(), takeUntil(this.unsubscribe || NEVER));
+        }
+        return this._loading;
+    }
+    get full() {
+        if (!this._full) {
+            this._full = this.queryset.full.pipe(
+            // tap(() => console.log('FULL')),
+            share(), takeUntil(this.unsubscribe || NEVER));
+        }
+        return this._full;
+    }
+    start(params) {
+        let filter$;
+        if (params.filter && !params.filter.subscribe) {
+            filter$ = of(params.filter);
+        }
+        else if (params.filter && params.filter.subscribe) {
+            filter$ = params.filter;
+        }
+        else {
+            filter$ = of({});
+        }
+        combineLatest([
+            this.reload,
+            this.filters.output,
+            filter$,
+            this.paginator.output,
+            this.sorter.output,
+            this.fields.output,
+        ])
+            .pipe(debounceTime(200), switchMap(([reload, filter, manualFilter, paginator, sorter, fields]) => {
+            this.queryset
+                .filter(filter)
+                .filter(manualFilter || {}, true)
+                .paginateBy(paginator.page_size)
+                .setPage(paginator.page)
+                .sort(...sorter)
+                .setFields(fields);
+            return this.queryset.get(true);
+        }), takeUntil(this.unsubscribe || NEVER))
+            .subscribe({
+            next: (results) => { },
+            error: (error) => {
+                console.error('Error while getting model list results : ', error);
+            },
+            complete: () => {
+                // console.log('modellist:completed', this.name);
+                this.started = false;
+            },
+        });
+        this.reload.next();
+        this.started = true;
+    }
+}
+export class ModelListService {
+    constructor() {
+        this._instances = new Map();
+    }
+    get(name, collection, defaults) {
+        let ml;
+        if (!name || !this._instances.has(name) || !defaults.keep) {
+            ml = new ModelList(name);
+            ml.queryset = collection.queryset();
+            ml.fields = new ModelListFields(collection, defaults.fields);
+            ml.sorter = new ModelListSorter(defaults.sorter || []);
+            ml.paginator = new ModelListPaginator(defaults.paginator);
+            ml.filters = new ModelListFilters(defaults.filters);
+            if (defaults.keep) {
+                this._instances.set(name, ml);
+            }
+        }
+        else {
+            ml = this._instances.get(name);
+        }
+        if (!ml.started) {
+            if (defaults.reload) {
+                ml.reload = defaults.reload;
+            }
+            else {
+                ml.reload = new Subject();
+            }
+            if (defaults.unsubscribe) {
+                ml.unsubscribe = defaults.unsubscribe;
+            }
+            else {
+                ml.unsubscribe = new Subject();
+            }
+            ml.start(defaults);
+        }
+        return ml;
+    }
+}
+ModelListService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.9", ngImport: i0, type: ModelListService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ModelListService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.9", ngImport: i0, type: ModelListService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.9", ngImport: i0, type: ModelListService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"model-list.service.js","sourceRoot":"","sources":["../../../../../projects/data/src/lib/modellist/model-list.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  combineLatest,\n  debounceTime,\n  NEVER,\n  Observable,\n  of,\n  share,\n  Subject,\n  takeUntil,\n} from 'rxjs';\nimport { DataModel } from '../data/data-model';\nimport {\n  IQueryMeta,\n  IQueryMetaNavParams,\n  IQueryNav,\n  Queryset,\n} from '../data/data-query';\nimport { switchMap, tap } from 'rxjs/operators';\nimport { ModelListFields } from './model-list-fields/model-list-fields';\nimport { ModelListPaginator } from './model-list-paginator/model-list-paginator';\nimport { ModelListSorter } from './model-list-sorter/model-list-sorter';\nimport { ModelListFilters } from './model-list-filters/model-list-filters';\nimport { Collection } from '../data/data-collection';\nimport { ModelListFilter } from './model-list-filters/model-list-filter';\n\nexport interface CustomField {\n  name: string;\n  label: string;\n}\n\nexport interface FilterDefaults {\n  [index: string]: string | number | undefined;\n}\n\nexport type SorterDefaults = string[];\n\n/**\n * Fields parameters.\n */\nexport interface FieldsParams {\n  /** Allowed fields, all model fields are allowed if empty */\n  allowed?: string[];\n  /** Default enabled fields */\n  defaults?: string[];\n  /** Excluded fields */\n  excluded?: string[];\n  /** Custom fields */\n  custom?: CustomField[];\n}\n\n/**\n * Filters parameters.\n */\nexport interface FiltersParams {\n  /** Allowed filter names */\n  allowed?: string[];\n  /** Default active filter names */\n  defaults?: string[];\n  /** Excluded filter names */\n  excluded?: string[];\n  /** Filters definitions */\n  filters?: ModelListFilter[];\n}\n\nexport type PaginationParams = IQueryMetaNavParams;\n\nexport interface ModelListParams {\n  fields?: FieldsParams;\n  filters?: FiltersParams;\n  filter?: FilterDefaults | Observable<FilterDefaults>;\n  sorter?: SorterDefaults;\n  paginator?: IQueryNav;\n  keep?: boolean;\n  reload?: Subject<void>;\n  unsubscribe?: Subject<void>;\n}\n\nexport class ModelList<T extends DataModel> {\n  public name!: string;\n  public filters!: ModelListFilters;\n  public sorter!: ModelListSorter;\n  public paginator!: ModelListPaginator;\n  public queryset!: Queryset<T>;\n  public fields!: ModelListFields<T>;\n  public reload!: Subject<void>;\n  public unsubscribe!: Subject<void>;\n  public started = false;\n\n  private _results?: Observable<T[]>;\n  private _meta?: Observable<IQueryMeta>;\n  private _loading?: Observable<boolean>;\n  private _full?: Observable<[T[], boolean, IQueryMeta]>;\n\n  constructor(name: string) {\n    this.name = name;\n  }\n\n  public get results(): Observable<T[]> {\n    if (!this._results) {\n      this._results = this.queryset.results.pipe(\n        // tap(() => console.log('RESULTS')),\n        share(),\n        takeUntil(this.unsubscribe || NEVER)\n      );\n    }\n    return this._results;\n  }\n\n  public get meta(): Observable<IQueryMeta> {\n    if (!this._meta) {\n      this._meta = this.queryset.meta.pipe(\n        // tap(() => console.log('META')),\n        share(),\n        takeUntil(this.unsubscribe || NEVER)\n      );\n    }\n    return this._meta;\n  }\n\n  public get loading(): Observable<boolean> {\n    if (!this._loading) {\n      this._loading = this.queryset.loading.pipe(\n        // tap(() => console.log('LOADING')),\n        share(),\n        takeUntil(this.unsubscribe || NEVER)\n      );\n    }\n    return this._loading;\n  }\n\n  public get full(): Observable<[T[], boolean, IQueryMeta]> {\n    if (!this._full) {\n      this._full = this.queryset.full.pipe(\n        // tap(() => console.log('FULL')),\n        share(),\n        takeUntil(this.unsubscribe || NEVER)\n      );\n    }\n    return this._full;\n  }\n\n  public start(params: ModelListParams) {\n    let filter$: Observable<FilterDefaults>;\n    if (params.filter && !params.filter.subscribe) {\n      filter$ = of(params.filter as FilterDefaults);\n    } else if (params.filter && params.filter.subscribe) {\n      filter$ = params.filter as Observable<FilterDefaults>;\n    } else {\n      filter$ = of({});\n    }\n    combineLatest([\n      this.reload,\n      this.filters.output,\n      filter$,\n      this.paginator.output,\n      this.sorter.output,\n      this.fields.output,\n    ])\n      .pipe(\n        debounceTime(200),\n        switchMap(\n          ([reload, filter, manualFilter, paginator, sorter, fields]) => {\n            this.queryset\n              .filter(filter)\n              .filter(manualFilter || {}, true)\n              .paginateBy(paginator.page_size)\n              .setPage(paginator.page)\n              .sort(...sorter)\n              .setFields(fields);\n            return this.queryset.get(true);\n          }\n        ),\n        takeUntil(this.unsubscribe || NEVER)\n      )\n      .subscribe({\n        next: (results: any): void => {},\n        error: (error) => {\n          console.error('Error while getting model list results : ', error);\n        },\n        complete: () => {\n          // console.log('modellist:completed', this.name);\n          this.started = false;\n        },\n      });\n    this.reload.next();\n    this.started = true;\n  }\n}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ModelListService {\n  private _instances: Map<string, ModelList<any>> = new Map();\n\n  constructor() {}\n\n  public get<T extends DataModel>(\n    name: string,\n    collection: Collection<T>,\n    defaults: ModelListParams\n  ) {\n    let ml: ModelList<T>;\n\n    if (!name || !this._instances.has(name) || !defaults.keep) {\n      ml = new ModelList<T>(name);\n      ml.queryset = collection.queryset();\n      ml.fields = new ModelListFields(collection, defaults.fields);\n      ml.sorter = new ModelListSorter(defaults.sorter || []);\n      ml.paginator = new ModelListPaginator(defaults.paginator);\n      ml.filters = new ModelListFilters(defaults.filters);\n      if (defaults.keep) {\n        this._instances.set(name, ml);\n      }\n    } else {\n      ml = this._instances.get(name)!;\n    }\n    if (!ml.started) {\n      if (defaults.reload) {\n        ml.reload = defaults.reload;\n      } else {\n        ml.reload = new Subject<void>();\n      }\n      if (defaults.unsubscribe) {\n        ml.unsubscribe = defaults.unsubscribe;\n      } else {\n        ml.unsubscribe = new Subject<void>();\n      }\n      ml.start(defaults);\n    }\n    return ml;\n  }\n}\n"]}

package/esm2020/lib/routing/breadcrumb/breadcrumb.component.mjs

@@ -0,0 +1,142 @@
+import { Component, Input, } from '@angular/core';
+import { Subject, takeUntil } from 'rxjs';
+import { NavigationEnd, RouterModule, } from '@angular/router';
+import { filter } from 'rxjs/operators';
+import { CommonModule } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "@angular/common";
+/**
+ * Use data from route config to create a breadcrumb for current route.
+ *
+ * Route config data is :
+ * - title : route fragment title or lodash template to build title
+ *   (provided arguments for template processing : route (current segment route snapshot)
+ *   and data (input argument)
+ * - icon: icon classes. Example fa fa-home for home & font awesome
+ */
+export class BreadcrumbComponent {
+    constructor(router, route) {
+        this.router = router;
+        this.route = route;
+        /**
+         * Do we display icons ?
+         */
+        this.icons = true;
+        this.tree = [];
+        this._subscriptions = new Subject();
+    }
+    ngOnInit() {
+        this.getRouteTree(this.router.routerState);
+        this.router.events
+            .pipe(takeUntil(this._subscriptions), filter((event) => event instanceof NavigationEnd))
+            .subscribe(() => {
+            this.getRouteTree(this.router.routerState);
+        });
+    }
+    ngOnDestroy() {
+        this._subscriptions.next();
+        this._subscriptions.complete();
+    }
+    ngOnChanges(changes) {
+        this.getRouteTree(this.router.routerState);
+    }
+    getRouteTree(current) {
+        const tree = [];
+        const url = [];
+        let p = current.root.snapshot;
+        while (p != null) {
+            let rdata = {
+                tree: false,
+                title: () => 'xxxx',
+                icon: '',
+                skip: true,
+            };
+            const data = p.data;
+            // Get route data
+            if (p.routeConfig && p.routeConfig.data) {
+                rdata = p.routeConfig.data;
+            }
+            if (rdata.tree) {
+                // Get icon
+                for (const u of p.url) {
+                    url.push(u.path);
+                    let rtd = {
+                        icon: this.getIcon(rdata, data),
+                        title: this.getTitle(rdata, data, u),
+                        path: url.join('/'),
+                        current: false,
+                    };
+                    if (rtd.path.length > 0 && rtd.path[0] !== '/') {
+                        rtd.path = '/' + rtd.path;
+                    }
+                    if (!rdata.skip) {
+                        tree.push(rtd);
+                    }
+                }
+            }
+            else {
+                url.push(p.url.join('/'));
+                let rtd = {
+                    icon: this.getIcon(rdata, data),
+                    title: this.getTitle(rdata, data),
+                    path: url.join('/'),
+                    current: false,
+                };
+                if (rtd.path.length > 0 && rtd.path[0] !== '/') {
+                    rtd.path = '/' + rtd.path;
+                }
+                if (!rdata.skip) {
+                    tree.push(rtd);
+                }
+            }
+            p = p.firstChild;
+        }
+        if (tree.length > 0) {
+            tree[tree.length - 1].current = true;
+        }
+        this.tree = tree;
+    }
+    getTitle(rdata, data, u) {
+        if (rdata['title']) {
+            if (typeof rdata['title'] === 'function') {
+                const tpl = rdata['title'];
+                try {
+                    if (u) {
+                        return tpl(data, u.path);
+                    }
+                    else {
+                        return tpl(data);
+                    }
+                }
+                catch (e) {
+                    console.warn('Unable to process breadcrumb function', e);
+                    if (data.title != null) {
+                        return 'xx';
+                    }
+                }
+            }
+            else {
+                return rdata['title'];
+            }
+        }
+        return 'xxx';
+    }
+    getIcon(rdata, data) {
+        if (data.icon) {
+            return data.icon;
+        }
+        return '';
+    }
+}
+BreadcrumbComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.9", ngImport: i0, type: BreadcrumbComponent, deps: [{ token: i1.Router }, { token: i1.ActivatedRoute }], target: i0.ɵɵFactoryTarget.Component });
+BreadcrumbComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.9", type: BreadcrumbComponent, isStandalone: true, selector: "data-breadcrumb", inputs: { data: "data", icons: "icons" }, usesOnChanges: true, ngImport: i0, template: "\n<nav aria-label=\"breadcrumb\">\n  <ol class=\"breadcrumb\">\n    <ng-container *ngFor=\"let p of tree\">\n      <li class=\"breadcrumb-item\" *ngIf=\"!p.current\"><a class=\"breadcrumb-item\" [routerLink]=\"p.path\">\n          <ng-container *ngIf=\"icons &amp;&amp; p.icon\"><i class=\"me-2\" [ngClass]=\"p.icon\"></i>{{p.title}}</ng-container>\n          <ng-container *ngIf=\"!(icons &amp;&amp; p.icon)\">{{p.title}}</ng-container></a></li>\n      <li class=\"breadcrumb-item active\" aria-current=\"page\" *ngIf=\"p.current\">\n        <ng-container *ngIf=\"icons &amp;&amp; p.icon\"><i class=\"me-1\" [ngClass]=\"p.icon\"></i>{{p.title}}</ng-container>\n        <ng-container *ngIf=\"!(icons &amp;&amp; p.icon)\">{{p.title}}</ng-container>\n      </li>\n    </ng-container>\n  </ol>\n</nav>", styles: [""], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: RouterModule }, { kind: "directive", type: i1.RouterLinkWithHref, selector: "a[routerLink],area[routerLink]", inputs: ["target", "queryParams", "fragment", "queryParamsHandling", "state", "relativeTo", "preserveFragment", "skipLocationChange", "replaceUrl", "routerLink"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.9", ngImport: i0, type: BreadcrumbComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'data-breadcrumb', standalone: true, imports: [CommonModule, RouterModule], template: "\n<nav aria-label=\"breadcrumb\">\n  <ol class=\"breadcrumb\">\n    <ng-container *ngFor=\"let p of tree\">\n      <li class=\"breadcrumb-item\" *ngIf=\"!p.current\"><a class=\"breadcrumb-item\" [routerLink]=\"p.path\">\n          <ng-container *ngIf=\"icons &amp;&amp; p.icon\"><i class=\"me-2\" [ngClass]=\"p.icon\"></i>{{p.title}}</ng-container>\n          <ng-container *ngIf=\"!(icons &amp;&amp; p.icon)\">{{p.title}}</ng-container></a></li>\n      <li class=\"breadcrumb-item active\" aria-current=\"page\" *ngIf=\"p.current\">\n        <ng-container *ngIf=\"icons &amp;&amp; p.icon\"><i class=\"me-1\" [ngClass]=\"p.icon\"></i>{{p.title}}</ng-container>\n        <ng-container *ngIf=\"!(icons &amp;&amp; p.icon)\">{{p.title}}</ng-container>\n      </li>\n    </ng-container>\n  </ol>\n</nav>" }]
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: i1.ActivatedRoute }]; }, propDecorators: { data: [{
+                type: Input
+            }], icons: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"breadcrumb.component.js","sourceRoot":"","sources":["../../../../../../projects/data/src/lib/routing/breadcrumb/breadcrumb.component.ts","../../../../../../projects/data/src/lib/routing/breadcrumb/breadcrumb.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  Input,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  SimpleChanges,\n} from '@angular/core';\nimport { Subject, takeUntil } from 'rxjs';\nimport {\n  ActivatedRoute,\n  ActivatedRouteSnapshot,\n  NavigationEnd,\n  Router,\n  RouterModule,\n  RouterState,\n  UrlSegment,\n} from '@angular/router';\nimport { filter } from 'rxjs/operators';\nimport { CommonModule } from '@angular/common';\nimport { BaseRouteParams, TplFn } from '../routing';\n\nexport interface IPathTreeItem {\n  path: string;\n  title: string;\n  icon: string;\n  current: boolean;\n}\n\n/**\n * Use data from route config to create a breadcrumb for current route.\n *\n * Route config data is :\n * - title : route fragment title or lodash template to build title\n *   (provided arguments for template processing : route (current segment route snapshot)\n *   and data (input argument)\n * - icon: icon classes. Example fa fa-home for home & font awesome\n */\n@Component({\n  selector: 'data-breadcrumb',\n  templateUrl: './breadcrumb.component.html',\n  styleUrls: ['./breadcrumb.component.css'],\n  standalone: true,\n  imports: [CommonModule, RouterModule],\n})\nexport class BreadcrumbComponent implements OnChanges, OnInit, OnDestroy {\n  /**\n   * Additional data to be used in titleTemplate\n   */\n  @Input() public data: any;\n  /**\n   * Do we display icons ?\n   */\n  @Input() public icons = true;\n  public tree: IPathTreeItem[] = [];\n  private _subscriptions = new Subject<void>();\n\n  constructor(public router: Router, public route: ActivatedRoute) {}\n\n  ngOnInit(): void {\n    this.getRouteTree(this.router.routerState);\n    this.router.events\n      .pipe(\n        takeUntil(this._subscriptions),\n        filter((event) => event instanceof NavigationEnd)\n      )\n      .subscribe(() => {\n        this.getRouteTree(this.router.routerState);\n      });\n  }\n\n  public ngOnDestroy() {\n    this._subscriptions.next();\n    this._subscriptions.complete();\n  }\n\n  public ngOnChanges(changes: SimpleChanges) {\n    this.getRouteTree(this.router.routerState);\n  }\n\n  public getRouteTree(current: RouterState): void {\n    const tree: IPathTreeItem[] = [];\n    const url: string[] = [];\n    let p: ActivatedRouteSnapshot | null = current.root.snapshot;\n\n    while (p != null) {\n      let rdata: Partial<BaseRouteParams> = {\n        tree: false,\n        title: () => 'xxxx',\n        icon: '',\n        skip: true,\n      };\n      const data = p.data as BaseRouteParams;\n\n      // Get route data\n      if (p.routeConfig && p.routeConfig.data) {\n        rdata = p.routeConfig.data as BaseRouteParams;\n      }\n\n      if (rdata.tree) {\n        // Get icon\n        for (const u of p.url) {\n          url.push(u.path);\n          let rtd: IPathTreeItem = {\n            icon: this.getIcon(rdata, data),\n            title: this.getTitle(rdata, data, u),\n            path: url.join('/'),\n            current: false,\n          };\n          if (rtd.path.length > 0 && rtd.path[0] !== '/') {\n            rtd.path = '/' + rtd.path;\n          }\n          if (!rdata.skip) {\n            tree.push(rtd);\n          }\n        }\n      } else {\n        url.push(p.url.join('/'));\n        let rtd: IPathTreeItem = {\n          icon: this.getIcon(rdata, data),\n          title: this.getTitle(rdata, data),\n          path: url.join('/'),\n          current: false,\n        };\n        if (rtd.path.length > 0 && rtd.path[0] !== '/') {\n          rtd.path = '/' + rtd.path;\n        }\n        if (!rdata.skip) {\n          tree.push(rtd);\n        }\n      }\n\n      p = p.firstChild;\n    }\n    if (tree.length > 0) {\n      tree[tree.length - 1].current = true;\n    }\n    this.tree = tree;\n  }\n\n  public getTitle(\n    rdata: Partial<BaseRouteParams>,\n    data: BaseRouteParams,\n    u?: UrlSegment\n  ): string {\n    if (rdata['title']) {\n      if (typeof rdata['title'] === 'function') {\n        const tpl: TplFn<any> = rdata['title'];\n        try {\n          if (u) {\n            return tpl(data, u.path);\n          } else {\n            return tpl(data);\n          }\n        } catch (e) {\n          console.warn('Unable to process breadcrumb function', e);\n          if (data.title != null) {\n            return 'xx';\n          }\n        }\n      } else {\n        return rdata['title'];\n      }\n    }\n    return 'xxx';\n  }\n\n  public getIcon(\n    rdata: Partial<BaseRouteParams>,\n    data: BaseRouteParams\n  ): string {\n    if (data.icon) {\n      return data.icon;\n    }\n    return '';\n  }\n}\n","\n<nav aria-label=\"breadcrumb\">\n  <ol class=\"breadcrumb\">\n    <ng-container *ngFor=\"let p of tree\">\n      <li class=\"breadcrumb-item\" *ngIf=\"!p.current\"><a class=\"breadcrumb-item\" [routerLink]=\"p.path\">\n          <ng-container *ngIf=\"icons &amp;&amp; p.icon\"><i class=\"me-2\" [ngClass]=\"p.icon\"></i>{{p.title}}</ng-container>\n          <ng-container *ngIf=\"!(icons &amp;&amp; p.icon)\">{{p.title}}</ng-container></a></li>\n      <li class=\"breadcrumb-item active\" aria-current=\"page\" *ngIf=\"p.current\">\n        <ng-container *ngIf=\"icons &amp;&amp; p.icon\"><i class=\"me-1\" [ngClass]=\"p.icon\"></i>{{p.title}}</ng-container>\n        <ng-container *ngIf=\"!(icons &amp;&amp; p.icon)\">{{p.title}}</ng-container>\n      </li>\n    </ng-container>\n  </ol>\n</nav>"]}

package/esm2020/lib/routing/routing.mjs

@@ -0,0 +1,57 @@
+export function RData(value) {
+    return value;
+}
+export class Link {
+    constructor(config, context, router) {
+        this._cargs = {};
+        this._params = [];
+        this._params = config.params || [];
+        this._route = config.route;
+        this._router = router;
+        this._name = config.name;
+        if (context) {
+            this.context(context);
+        }
+    }
+    get name() {
+        return this._name;
+    }
+    context(ctx) {
+        for (const n of this._params) {
+            if (ctx && ctx[n]) {
+                this._cargs[n] = ctx[n];
+            }
+            else {
+                this._cargs[n] = null;
+            }
+        }
+    }
+    route(params) {
+        const rargs = [];
+        for (const n of this._params) {
+            if (params && params[n] !== undefined && params[n] !== null) {
+                rargs.push(params[n]);
+            }
+            else if (this._cargs[n] !== undefined && this._cargs[n] !== null) {
+                rargs.push(this._cargs[n]);
+            }
+            else {
+                console.error('Missing route parameter', n);
+                return [];
+            }
+        }
+        // SEE: Check for undefined in rargs
+        return this._route(...rargs);
+    }
+    async navigate(params, router) {
+        if (router) {
+            return router.navigate(this.route(params));
+        }
+        if (this._router) {
+            return this._router.navigate(this.route(params));
+        }
+        console.error('Router not provided, no navigation');
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/uploader/index.mjs

@@ -0,0 +1,6 @@
+export * from "./interfaces";
+export * from "./ng-file-drop.directive";
+export * from "./ng-file-select.directive";
+export * from "./ngx-uploader.class";
+export * from "./ngx-uploader.module";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9kYXRhL3NyYy9saWIvdXBsb2FkZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyx1QkFBdUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2ludGVyZmFjZXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL25nLWZpbGUtZHJvcC5kaXJlY3RpdmVcIjtcbmV4cG9ydCAqIGZyb20gXCIuL25nLWZpbGUtc2VsZWN0LmRpcmVjdGl2ZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vbmd4LXVwbG9hZGVyLmNsYXNzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9uZ3gtdXBsb2FkZXIubW9kdWxlXCI7XG4iXX0=

package/esm2020/lib/uploader/interfaces.mjs

@@ -0,0 +1,8 @@
+export var UploadStatus;
+(function (UploadStatus) {
+    UploadStatus[UploadStatus["Queue"] = 0] = "Queue";
+    UploadStatus[UploadStatus["Uploading"] = 1] = "Uploading";
+    UploadStatus[UploadStatus["Done"] = 2] = "Done";
+    UploadStatus[UploadStatus["Cancelled"] = 3] = "Cancelled";
+})(UploadStatus || (UploadStatus = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/uploader/ng-file-drop.directive.mjs

@@ -0,0 +1,81 @@
+import { Directive, EventEmitter, HostListener, Input, Output } from "@angular/core";
+import { DataUploaderService } from "./ngx-uploader.class";
+import * as i0 from "@angular/core";
+export class NgFileDropDirective {
+    constructor(elementRef) {
+        this.elementRef = elementRef;
+        this.stopEvent = (e) => {
+            e.stopPropagation();
+            e.preventDefault();
+        };
+        this.uploadOutput = new EventEmitter();
+    }
+    ngOnInit() {
+        this._sub = [];
+        const concurrency = this.options && this.options.concurrency || Number.POSITIVE_INFINITY;
+        const allowedContentTypes = this.options && this.options.allowedContentTypes || ["*"];
+        const maxUploads = this.options && this.options.maxUploads || Number.POSITIVE_INFINITY;
+        const maxFileSize = this.options && this.options.maxFileSize || Number.POSITIVE_INFINITY;
+        this.upload = new DataUploaderService(concurrency, allowedContentTypes, maxUploads, maxFileSize);
+        this.el = this.elementRef.nativeElement;
+        this._sub.push(this.upload.serviceEvents.subscribe((event) => {
+            this.uploadOutput.emit(event);
+        }));
+        if (this.uploadInput instanceof EventEmitter) {
+            this._sub.push(this.upload.initInputEvents(this.uploadInput));
+        }
+        this.el.addEventListener("drop", this.stopEvent, false);
+        this.el.addEventListener("dragenter", this.stopEvent, false);
+        this.el.addEventListener("dragover", this.stopEvent, false);
+    }
+    ngOnDestroy() {
+        if (this._sub) {
+            this._sub.forEach(sub => sub.unsubscribe());
+        }
+    }
+    onDrop(e) {
+        e.stopPropagation();
+        e.preventDefault();
+        const event = { type: "drop" };
+        this.uploadOutput.emit(event);
+        this.upload.handleFiles(e.dataTransfer.files);
+    }
+    onDragOver(e) {
+        if (!e) {
+            return;
+        }
+        const event = { type: "dragOver" };
+        this.uploadOutput.emit(event);
+    }
+    onDragLeave(e) {
+        if (!e) {
+            return;
+        }
+        const event = { type: "dragOut" };
+        this.uploadOutput.emit(event);
+    }
+}
+NgFileDropDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.9", ngImport: i0, type: NgFileDropDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+NgFileDropDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.9", type: NgFileDropDirective, selector: "[dataFileDrop]", inputs: { options: "options", uploadInput: "uploadInput" }, outputs: { uploadOutput: "uploadOutput" }, host: { listeners: { "drop": "onDrop($event)", "dragover": "onDragOver($event)", "dragleave": "onDragLeave($event)" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.9", ngImport: i0, type: NgFileDropDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[dataFileDrop]"
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { options: [{
+                type: Input
+            }], uploadInput: [{
+                type: Input
+            }], uploadOutput: [{
+                type: Output
+            }], onDrop: [{
+                type: HostListener,
+                args: ["drop", ["$event"]]
+            }], onDragOver: [{
+                type: HostListener,
+                args: ["dragover", ["$event"]]
+            }], onDragLeave: [{
+                type: HostListener,
+                args: ["dragleave", ["$event"]]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/uploader/ng-file-select.directive.mjs

@@ -0,0 +1,51 @@
+import { Directive, EventEmitter, Input, Output } from "@angular/core";
+import { DataUploaderService } from "./ngx-uploader.class";
+import * as i0 from "@angular/core";
+export class NgFileSelectDirective {
+    constructor(elementRef) {
+        this.elementRef = elementRef;
+        this.fileListener = () => {
+            if (this.el.files) {
+                this.upload.handleFiles(this.el.files);
+            }
+        };
+        this.uploadOutput = new EventEmitter();
+    }
+    ngOnInit() {
+        this._sub = [];
+        const concurrency = this.options && this.options.concurrency || Number.POSITIVE_INFINITY;
+        const allowedContentTypes = this.options && this.options.allowedContentTypes || ["*"];
+        const maxUploads = this.options && this.options.maxUploads || Number.POSITIVE_INFINITY;
+        const maxFileSize = this.options && this.options.maxFileSize || Number.POSITIVE_INFINITY;
+        this.upload = new DataUploaderService(concurrency, allowedContentTypes, maxUploads, maxFileSize);
+        this.el = this.elementRef.nativeElement;
+        this.el.addEventListener("change", this.fileListener, false);
+        this._sub.push(this.upload.serviceEvents.subscribe((event) => {
+            this.uploadOutput.emit(event);
+        }));
+        if (this.uploadInput instanceof EventEmitter) {
+            this._sub.push(this.upload.initInputEvents(this.uploadInput));
+        }
+    }
+    ngOnDestroy() {
+        if (this.el) {
+            this.el.removeEventListener("change", this.fileListener, false);
+            this._sub.forEach(sub => sub.unsubscribe());
+        }
+    }
+}
+NgFileSelectDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.9", ngImport: i0, type: NgFileSelectDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+NgFileSelectDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.9", type: NgFileSelectDirective, selector: "[dataFileSelect]", inputs: { options: "options", uploadInput: "uploadInput" }, outputs: { uploadOutput: "uploadOutput" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.9", ngImport: i0, type: NgFileSelectDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[dataFileSelect]"
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { options: [{
+                type: Input
+            }], uploadInput: [{
+                type: Input
+            }], uploadOutput: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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