@coolon/angular-ui-powerups 0.0.26 → 0.0.28

package/src/lib/place/route/parameter-type.ts

@@ -1,31 +0,0 @@
-export interface ParameterType<T> {
-  format(value: T): string;
-
-  parse(value: string): T;
-}
-
-export namespace ParameterType {
-
-  class StringType implements ParameterType<string> {
-    format(value: string): string {
-      return value;
-    }
-
-    parse(value: string): string {
-      return value;
-    }
-  }
-
-  class NumberType implements ParameterType<number> {
-    format(value: number): string {
-      return `${value}`;
-    }
-
-    parse(value: string): number {
-      return +value;
-    }
-  }
-
-  export const STRING = new StringType();
-  export const NUMBER = new NumberType();
-}

package/src/lib/place/route/route-parameter-bindings.ts

@@ -1,140 +0,0 @@
-import { ActivatedRoute, Router } from '@angular/router';
-import {
-  Binding,
-  Dsl,
-  GarbageCollector, IMutableHasValue,
-  MutableValueModel,
-  Trace,
-  TransactionObserver
-} from '@coolon/pectin';
-import { Klass } from '@coolon/typescript-utilities';
-import { ParameterDefinition } from './parameter-definition.class';
-
-interface ResolvedParameter<T> {
-  parameterDef: ParameterDefinition<T>;
-  resolvedValue: T;
-}
-
-class ResolvedParameters {
-  constructor(readonly parameters: ResolvedParameter<any>[]) {
-  }
-
-  get<T>(parameter: ParameterDefinition<T>): T {
-    const resolved = this.parameters.find(p => p.parameterDef === parameter);
-    return resolved ? resolved.resolvedValue : null;
-  }
-
-  replace<T>(parameter: ParameterDefinition<T>, value: T): ResolvedParameters {
-    return new ResolvedParameters(this.parameters.filter(p => p.parameterDef !== parameter).concat({
-      parameterDef: parameter,
-      resolvedValue: value
-    }));
-  }
-
-  @Trace()
-  protected getFormattedRouteId() {
-    const routeIdParam = this.getRouteIdParam();
-    return routeIdParam ? routeIdParam.parameterDef.type.format(routeIdParam.resolvedValue) : null;
-  }
-
-  private getRouteIdParam() {
-    return this.parameters.find(p => p.parameterDef.isRouteId);
-  }
-
-  @Trace()
-  protected getFormattedParameters() {
-    const params = {};
-    const routeIdParam = this.parameters.filter(p => !p.parameterDef.isRouteId).forEach(p => {
-      params[p.parameterDef.name] = p.parameterDef.type.format(p.resolvedValue);
-    });
-    return params;
-  }
-
-  hasRouteId() {
-    return !!this.getRouteIdParam();
-  }
-
-  @Trace()
-  redirect(previous: ResolvedParameters, router: Router, activatedRoute: ActivatedRoute) {
-    const routeId = this.getFormattedRouteId();
-    const relativePath = !!previous.hasRouteId() ? '..' : '.';
-    const path = routeId ? [relativePath, routeId, this.getFormattedParameters()] : [relativePath, this.getFormattedParameters()];
-    router.navigate(path, {
-      relativeTo: activatedRoute
-    });
-  }
-}
-
-export class RouteParameterBindings extends GarbageCollector {
-
-  public readonly _incomingRouteChange = new MutableValueModel<boolean>(false);
-
-  private txo: TransactionObserver;
-
-  private readonly resolvedParameters = new MutableValueModel<ResolvedParameters>();
-
-  constructor(private readonly component: any, private readonly router: Router, private readonly activatedRoute: ActivatedRoute) {
-    super();
-    const { chain, valueOf, before, when, after, observe } = Dsl.disposeWith(this);
-    this.txo = new TransactionObserver();//.onEvent(e => console.log(e.toString()));
-
-    const routeParameterDefs: ParameterDefinition<any>[] = Klass.get(component).getMetadataList(RouteParameterBindings.ROUTE_PARAMETER_LIST_KEY);
-    routeParameterDefs.forEach(parameter => this.installBinding(parameter));
-
-    const incomingResolvedRouteParameters = observe.valuesFrom(activatedRoute.paramMap)
-      .last()
-      .map(params => {
-        const result: ResolvedParameter<any>[] = [];
-        routeParameterDefs.forEach(parameterDef => {
-          let resolvedValue;
-          if (parameterDef.isArray) {
-            resolvedValue = params.getAll(parameterDef.name).map(v => parameterDef.type.parse(v));
-          } else {
-            resolvedValue = parameterDef.type.parse(params.get(parameterDef.name));
-          }
-          result.push({ parameterDef: parameterDef, resolvedValue: resolvedValue });
-
-        });
-        return new ResolvedParameters(result);
-      });
-
-    incomingResolvedRouteParameters.subscribe(resolvedParameters => {
-      this._incomingRouteChange.value = true;
-      this.resolvedParameters.value = resolvedParameters;
-      this._incomingRouteChange.value = false;
-    });
-
-    when.valueOf(this.resolvedParameters).changes((params, previous) => {
-      params.redirect(previous, router, activatedRoute);
-    }, { unless: this.incomingRouteChange });
-
-    this.txo.observe('incomingResolvedRouteParameters', incomingResolvedRouteParameters);
-    this.txo.observe('this.routeIsChanging', this.incomingRouteChange);
-  }
-
-  get incomingRouteChange() {
-    return this._incomingRouteChange.readonly;
-  }
-
-  protected installBinding<T>(parameter: ParameterDefinition<T>) {
-    const model = this.getModelFor(parameter);
-    // this.txo.observe(parameter.propertyName, model);
-    this.registerDisposable(new Binding(this.resolvedParameters, model, {
-      toRight(parameters: ResolvedParameters): T {
-        return parameters.get(parameter);
-      },
-      toLeft(value: T, currentParameters?: ResolvedParameters): ResolvedParameters {
-        return currentParameters.replace(parameter, value);
-      }
-    }));
-  }
-
-
-  private getModelFor<T>(parameter: ParameterDefinition<T>): IMutableHasValue<T> {
-    return this.component[parameter.propertyName];
-  }
-}
-
-export namespace RouteParameterBindings {
-  export const ROUTE_PARAMETER_LIST_KEY = Symbol('place:route:parameters');
-}

package/src/lib/place/route/route-parameter-sanitiser.ts

@@ -1,135 +0,0 @@
-import { Injector } from '@angular/core';
-import { ActivatedRouteSnapshot, Router } from '@angular/router';
-import { assert } from '@coolon/pectin';
-import { Memoize } from '@typescript-plus/fast-memoize-decorator/dist/src';
-import { ParameterDefinition } from './parameter-definition.class';
-import { ParameterSanitiser } from './parameter-sanitiser';
-import * as _ from 'lodash';
-
-export abstract class Sanitiser<T, S> {
-
-  private initialValue: S;
-  private _sanitisedValue: S;
-
-  constructor(readonly parameterDef: ParameterDefinition<T>, readonly snapshot:ActivatedRouteSnapshot, readonly sanitiser: ParameterSanitiser<S>) {
-  }
-
-  isRouteId(): boolean {
-    return this.parameterDef.isRouteId;
-  }
-
-  get valueChanged():boolean {
-    return !_.isNil(this.initialValue) && this.hasChanged(this.initialValue, this.sanitisedValue);
-  }
-
-  get sanitisedValue():S {
-    return this._sanitisedValue;
-  }
-
-  protected abstract readFrom(snapshot: ActivatedRouteSnapshot): S;
-  protected abstract hasChanged(initialValue:S, sanitisedValue:S): boolean;
-
-  abstract injectRouteParam(dest: {});
-
-  async sanitize(): Promise<boolean> {
-    if (this.sanitiser) {
-      this.initialValue = this.readFrom(this.snapshot);
-      this._sanitisedValue = await this.sanitiser.sanitise(this.initialValue);
-      if (this.initialValue !== this._sanitisedValue) {
-        return false;
-      }
-    }
-    return true;
-  }
-}
-
-
-export class RouteParameterSanitiser {
-
-  private readonly routeIdSanitiser: Sanitiser<any, any>;
-  private readonly parameterSanitisers: Sanitiser<any, any>[] = [];
-
-  constructor(readonly parameterDefs: ParameterDefinition<any>[], readonly snapshot: ActivatedRouteSnapshot, readonly injector: Injector) {
-    const sanitisers = parameterDefs.map(def => {
-      return def.isArray ?
-        new Sanitiser.Array(def, snapshot, this.getSanitiser(def)) :
-        new Sanitiser.Value(def, snapshot, this.getSanitiser(def));
-    });
-    this.routeIdSanitiser = sanitisers.find(p => p.isRouteId());
-    this.parameterSanitisers = sanitisers.filter(p => !p.isRouteId());
-  }
-
-  async sanitise(): Promise<boolean> {
-    if (this.routeIdSanitiser) {
-      await this.routeIdSanitiser.sanitize();
-      if (this.routeIdSanitiser.valueChanged) {
-        // if the route id isn't ok we redirect immediately as the query params may need to be sanitised in the
-        // context of the route id.
-        return false;
-      }
-    }
-    for (const sanitiser of this.parameterSanitisers) {
-        await sanitiser.sanitize();
-    }
-    return !this.parameterSanitisers.find(s => s.valueChanged);
-  }
-
-  redirect(router: Router) {
-    assert.isTruthy(this.parameterSanitisers.length !== 0);
-    if (this.routeIdSanitiser.valueChanged) {
-      return router.navigate(['..', this.routeIdSanitiser.sanitisedValue]);
-    } else {
-      const routeParams = {};
-      this.parameterSanitisers.forEach(s => s.injectRouteParam(routeParams));
-      return router.navigate(['.', routeParams]);
-    }
-  }
-
-  @Memoize()
-  private getSanitiser<T, S>(def: ParameterDefinition<T, S>): ParameterSanitiser<S> {
-    return def.sanitiser ? this.injector.get<ParameterSanitiser<S>>(def.sanitiser, new def.sanitiser()) : null;
-  }
-}
-
-export namespace Sanitiser {
-
-  export class Value<T> extends Sanitiser<T, T> {
-
-    readFrom(snapshot: ActivatedRouteSnapshot): T {
-      const rawValue = this.parameterDef.isRouteId ?
-        snapshot.paramMap.get(this.parameterDef.name) :
-        snapshot.queryParamMap.get(this.parameterDef.name);
-
-      return this.parameterDef.type.parse(rawValue);
-    }
-
-    protected hasChanged(initialValue: T, sanitisedValue: T): boolean {
-      return initialValue !== sanitisedValue;
-    }
-
-    injectRouteParam(dest: {}) {
-      dest[this.parameterDef.name] = this.parameterDef.type.format(this.sanitisedValue);
-    }
-
-  }
-
-  export class Array<T> extends Sanitiser<T, T[]> {
-
-    readFrom(snapshot: ActivatedRouteSnapshot): T[] {
-      const rawValues = snapshot.queryParamMap.getAll(this.parameterDef.name);
-      return rawValues.map(value => this.parameterDef.type.parse(value));
-    }
-
-    protected hasChanged(initialValue: T[], sanitisedValue: T[]): boolean {
-      return initialValue !== sanitisedValue;
-    }
-
-
-    injectRouteParam(dest: {}) {
-      dest[this.parameterDef.name] = this.sanitisedValue.map(v => this.parameterDef.type.format(v));
-    }
-
-
-  }
-
-}

package/src/test-setup.ts

@@ -1 +0,0 @@
-import 'jest-preset-angular';

package/tsconfig.json

@@ -1,7 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "types": ["node", "jest"]
-  },
-  "include": ["**/*.ts"]
-}

package/tsconfig.lib.json

@@ -1,20 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "outDir": "../../dist/out-tsc",
-    "target": "es2015",
-    "declaration": true,
-    "inlineSources": true,
-    "types": [],
-    "lib": ["dom", "es2018"]
-  },
-  "angularCompilerOptions": {
-    "annotateForClosureCompiler": true,
-    "skipTemplateCodegen": true,
-    "strictMetadataEmit": true,
-    "fullTemplateTypeCheck": true,
-    "strictInjectionParameters": true,
-    "enableResourceInlining": true
-  },
-  "exclude": ["src/test.ts", "**/*.spec.ts"]
-}

package/tsconfig.schematics.json

@@ -1,35 +0,0 @@
-{
-  "compilerOptions": {
-    "baseUrl": ".",
-    "lib": [
-      "es2018",
-      "dom"
-    ],
-    "declaration": true,
-    "module": "commonjs",
-    "moduleResolution": "node",
-    "noEmitOnError": true,
-    "noFallthroughCasesInSwitch": true,
-    "noImplicitAny": true,
-    "noImplicitThis": true,
-    "noUnusedParameters": false,
-    "noUnusedLocals": false,
-    "rootDir": "schematics",
-    "outDir": "../../dist/libs/angular-ui-powerups/schematics",
-    "skipDefaultLibCheck": true,
-    "skipLibCheck": true,
-    "sourceMap": true,
-    "strictNullChecks": false,
-    "experimentalDecorators": true,
-    "target": "es6",
-    "types": [
-      "node"
-    ]
-  },
-  "include": [
-    "schematics/**/*"
-  ],
-  "exclude": [
-    "schematics/*/templates/**/*"
-  ]
-}

package/tsconfig.spec.json

@@ -1,10 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "outDir": "../../dist/out-tsc",
-    "module": "commonjs",
-    "types": ["jest", "node"]
-  },
-  "files": ["src/test-setup.ts"],
-  "include": ["**/*.spec.ts", "**/*.d.ts"]
-}

package/tslint.json

@@ -1,7 +0,0 @@
-{
-  "extends": "../../tslint.json",
-  "rules": {
-    "directive-selector": [true, "attribute", "angularUiPowerups", "camelCase"],
-    "component-selector": [true, "element", "angular-ui-powerups", "kebab-case"]
-  }
-}