reusable extensibility lib (#585)

reusable extensibility lib (part 1)

projects/aca-dev-tools/src/lib/aca-dev-tools.module.ts

@@ -4,6 +4,7 @@ import { FlexLayoutModule } from '@angular/flex-layout';
 import { AcaDevToolsComponent } from './aca-dev-tools.component';
 import { CoreModule } from '@alfresco/adf-core';
 import { ContentModule } from '@alfresco/adf-content-services';
+import { ExtensionService } from '@alfresco/adf-extensions';
 
 @NgModule({
     imports: [
@@ -16,4 +17,10 @@ import { ContentModule } from '@alfresco/adf-content-services';
     exports: [AcaDevToolsComponent],
     entryComponents: [AcaDevToolsComponent]
 })
-export class AcaDevToolsModule {}
+export class AcaDevToolsModule {
+    constructor(extensions: ExtensionService) {
+        extensions.setComponents({
+            'app.dev.tools.component': AcaDevToolsComponent
+        });
+    }
+}

projects/aca-dev-tools/src/lib/aca-dev-tools.service.spec.ts

@@ -1,15 +0,0 @@
-import { TestBed, inject } from '@angular/core/testing';
-
-import { AcaDevToolsService } from './aca-dev-tools.service';
-
-describe('AcaDevToolsService', () => {
-  beforeEach(() => {
-    TestBed.configureTestingModule({
-      providers: [AcaDevToolsService]
-    });
-  });
-
-  it('should be created', inject([AcaDevToolsService], (service: AcaDevToolsService) => {
-    expect(service).toBeTruthy();
-  }));
-});

projects/aca-dev-tools/src/lib/aca-dev-tools.service.ts

@@ -1,9 +0,0 @@
-import { Injectable } from '@angular/core';
-
-@Injectable({
-  providedIn: 'root'
-})
-export class AcaDevToolsService {
-
-  constructor() { }
-}

projects/aca-dev-tools/src/public_api.ts

@@ -2,6 +2,5 @@
  * Public API Surface of aca-dev-tools
  */
 
-export * from './lib/aca-dev-tools.service';
 export * from './lib/aca-dev-tools.component';
 export * from './lib/aca-dev-tools.module';

projects/adf-extensions/karma.conf.js

@@ -0,0 +1,31 @@
+// Karma configuration file, see link for more information
+// https://karma-runner.github.io/1.0/config/configuration-file.html
+
+module.exports = function (config) {
+  config.set({
+    basePath: '',
+    frameworks: ['jasmine', '@angular-devkit/build-angular'],
+    plugins: [
+      require('karma-jasmine'),
+      require('karma-chrome-launcher'),
+      require('karma-jasmine-html-reporter'),
+      require('karma-coverage-istanbul-reporter'),
+      require('@angular-devkit/build-angular/plugins/karma')
+    ],
+    client: {
+      clearContext: false // leave Jasmine Spec Runner output visible in browser
+    },
+    coverageIstanbulReporter: {
+      dir: require('path').join(__dirname, '../../coverage'),
+      reports: ['html', 'lcovonly'],
+      fixWebpackSourcePaths: true
+    },
+    reporters: ['progress', 'kjhtml'],
+    port: 9876,
+    colors: true,
+    logLevel: config.LOG_INFO,
+    autoWatch: true,
+    browsers: ['Chrome'],
+    singleRun: false
+  });
+};

projects/adf-extensions/ng-package.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "../../node_modules/ng-packagr/ng-package.schema.json",
+  "dest": "../../dist/@alfresco/adf-extensions",
+  "deleteDestPath": false,
+  "lib": {
+    "languageLevel": ["dom", "es2017"],
+    "entryFile": "src/public_api.ts"
+  }
+}

projects/adf-extensions/ng-package.prod.json

@@ -0,0 +1,8 @@
+{
+  "$schema": "../../node_modules/ng-packagr/ng-package.schema.json",
+  "dest": "../../dist/@alfresco/adf-extensions",
+  "lib": {
+    "languageLevel": ["dom", "es2017"],
+    "entryFile": "src/public_api.ts"
+  }
+}

projects/adf-extensions/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@alfresco/adf-extensions",
+  "version": "0.0.1",
+  "peerDependencies": {
+    "@angular/common": "^6.0.0",
+    "@angular/core": "^6.0.0",
+    "@angular/http": "^6.1.4",
+    "alfresco-js-api": "^2.5.0"
+  }
+}

projects/adf-extensions/src/lib/components/dynamic-component/dynamic.component.ts

@@ -0,0 +1,67 @@
+/*!
+ * @license
+ * Copyright 2016 - 2018 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+    Component,
+    Input,
+    ComponentRef,
+    OnInit,
+    ComponentFactoryResolver,
+    ViewChild,
+    ViewContainerRef,
+    OnDestroy
+} from '@angular/core';
+import { ExtensionService } from '../../services/extension.service';
+
+@Component({
+    selector: 'adf-dynamic-component',
+    template: `<div #content></div>`
+})
+export class DynamicExtensionComponent implements OnInit, OnDestroy {
+    @ViewChild('content', { read: ViewContainerRef })
+    content: ViewContainerRef;
+
+    @Input() id: string;
+
+    private componentRef: ComponentRef<any>;
+
+    constructor(
+        private extensions: ExtensionService,
+        private componentFactoryResolver: ComponentFactoryResolver
+    ) {}
+
+    ngOnInit() {
+        const componentType = this.extensions.getComponentById(this.id);
+        if (componentType) {
+            const factory = this.componentFactoryResolver.resolveComponentFactory(
+                componentType
+            );
+            if (factory) {
+                this.content.clear();
+                this.componentRef = this.content.createComponent(factory, 0);
+                // this.setupWidget(this.componentRef);
+            }
+        }
+    }
+
+    ngOnDestroy() {
+        if (this.componentRef) {
+            this.componentRef.destroy();
+            this.componentRef = null;
+        }
+    }
+}

projects/adf-extensions/src/lib/components/dynamic-tab/dynamic-tab.component.ts

@@ -0,0 +1,94 @@
+/*!
+ * @license
+ * Alfresco Example Content Application
+ *
+ * Copyright (C) 2005 - 2018 Alfresco Software Limited
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail.  Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import {
+    Component,
+    Input,
+    OnInit,
+    OnDestroy,
+    ViewChild,
+    ViewContainerRef,
+    ComponentRef,
+    ComponentFactoryResolver,
+    OnChanges,
+    SimpleChanges
+} from '@angular/core';
+import { MinimalNodeEntryEntity } from 'alfresco-js-api';
+import { ExtensionService } from '../../services/extension.service';
+
+@Component({
+    selector: 'adf-dynamic-tab',
+    template: `<div #content></div>`
+})
+export class DynamicTabComponent implements OnInit, OnChanges, OnDestroy {
+    @ViewChild('content', { read: ViewContainerRef })
+    content: ViewContainerRef;
+
+    @Input()
+    id: string;
+
+    @Input()
+    node: MinimalNodeEntryEntity;
+
+    private componentRef: ComponentRef<any>;
+
+    constructor(
+        private extensions: ExtensionService,
+        private componentFactoryResolver: ComponentFactoryResolver
+    ) {}
+
+    ngOnInit() {
+        const componentType = this.extensions.getComponentById(this.id);
+        if (componentType) {
+            const factory = this.componentFactoryResolver.resolveComponentFactory(
+                componentType
+            );
+            if (factory) {
+                this.content.clear();
+                this.componentRef = this.content.createComponent(factory, 0);
+                this.updateInstance();
+            }
+        }
+    }
+
+    ngOnChanges(changes: SimpleChanges) {
+        if (changes.node) {
+            this.updateInstance();
+        }
+    }
+
+    ngOnDestroy() {
+        if (this.componentRef) {
+            this.componentRef.destroy();
+            this.componentRef = null;
+        }
+    }
+
+    private updateInstance() {
+        if (this.componentRef && this.componentRef.instance) {
+            this.componentRef.instance.node = this.node;
+        }
+    }
+}

projects/adf-extensions/src/lib/config/action.extensions.ts

@@ -0,0 +1,51 @@
+/*!
+ * @license
+ * Copyright 2016 - 2018 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { ExtensionElement } from './extension-element';
+
+export enum ContentActionType {
+    default = 'default',
+    button = 'button',
+    separator = 'separator',
+    menu = 'menu',
+    custom = 'custom'
+}
+
+export interface ContentActionRef extends ExtensionElement {
+    type: ContentActionType;
+
+    title?: string;
+    description?: string;
+    icon?: string;
+    children?: Array<ContentActionRef>;
+    component?: string;
+    actions?: {
+        click?: string;
+        [key: string]: string;
+    };
+    rules?: {
+        enabled?: string;
+        visible?: string;
+        [key: string]: string;
+    };
+}
+
+export interface ActionRef {
+    id: string;
+    type: string;
+    payload?: string;
+}

projects/adf-extensions/src/lib/config/extension-element.ts

@@ -0,0 +1,23 @@
+/*!
+ * @license
+ * Copyright 2016 - 2018 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export interface ExtensionElement {
+    id: string;
+
+    order?: number;
+    disabled?: boolean;
+}

projects/adf-extensions/src/lib/config/extension-utils.ts

@@ -0,0 +1,150 @@
+/*!
+ * @license
+ * Copyright 2016 - 2018 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { ContentActionRef, ContentActionType } from './action.extensions';
+
+export function getValue(target: any, key: string): any {
+    if (!target) {
+        return undefined;
+    }
+
+    const keys = key.split('.');
+    key = '';
+
+    do {
+        key += keys.shift();
+        const value = target[key];
+        if (
+            value !== undefined &&
+            (typeof value === 'object' || !keys.length)
+        ) {
+            target = value;
+            key = '';
+        } else if (!keys.length) {
+            target = undefined;
+        } else {
+            key += '.';
+        }
+    } while (keys.length);
+
+    return target;
+}
+
+export function filterEnabled(entry: { disabled?: boolean }): boolean {
+    return !entry.disabled;
+}
+
+export function sortByOrder(
+    a: { order?: number | undefined },
+    b: { order?: number | undefined }
+) {
+    const left = a.order === undefined ? Number.MAX_SAFE_INTEGER : a.order;
+    const right = b.order === undefined ? Number.MAX_SAFE_INTEGER : b.order;
+    return left - right;
+}
+
+export function reduceSeparators(
+    acc: ContentActionRef[],
+    el: ContentActionRef,
+    i: number,
+    arr: ContentActionRef[]
+): ContentActionRef[] {
+    // remove leading separator
+    if (i === 0) {
+        if (arr[i].type === ContentActionType.separator) {
+            return acc;
+        }
+    }
+    // remove duplicate separators
+    if (i > 0) {
+        const prev = arr[i - 1];
+        if (
+            prev.type === ContentActionType.separator &&
+            el.type === ContentActionType.separator
+        ) {
+            return acc;
+        }
+
+        // remove trailing separator
+        if (i === arr.length - 1) {
+            if (el.type === ContentActionType.separator) {
+                return acc;
+            }
+        }
+    }
+
+    return acc.concat(el);
+}
+
+export function reduceEmptyMenus(
+    acc: ContentActionRef[],
+    el: ContentActionRef
+): ContentActionRef[] {
+    if (el.type === ContentActionType.menu) {
+        if ((el.children || []).length === 0) {
+            return acc;
+        }
+    }
+    return acc.concat(el);
+}
+
+export function mergeObjects(...objects): any {
+    const result = {};
+
+    objects.forEach(source => {
+        Object.keys(source).forEach(prop => {
+            if (!prop.startsWith('$')) {
+                if (prop in result && Array.isArray(result[prop])) {
+                    // result[prop] = result[prop].concat(source[prop]);
+                    result[prop] = mergeArrays(result[prop], source[prop]);
+                } else if (prop in result && typeof result[prop] === 'object') {
+                    result[prop] = mergeObjects(result[prop], source[prop]);
+                } else {
+                    result[prop] = source[prop];
+                }
+            }
+        });
+    });
+
+    return result;
+}
+
+export function mergeArrays(left: any[], right: any[]): any[] {
+    const result = [];
+    const map = {};
+
+    (left || []).forEach(entry => {
+        const element = entry;
+        if (element && element.hasOwnProperty('id')) {
+            map[element.id] = element;
+        } else {
+            result.push(element);
+        }
+    });
+
+    (right || []).forEach(entry => {
+        const element = entry;
+        if (element && element.hasOwnProperty('id') && map[element.id]) {
+            const merged = mergeObjects(map[element.id], element);
+            map[element.id] = merged;
+        } else {
+            result.push(element);
+        }
+    });
+
+    return Object.values(map).concat(result);
+}

projects/adf-extensions/src/lib/config/extension.config.ts

@@ -0,0 +1,35 @@
+/*!
+ * @license
+ * Copyright 2016 - 2018 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { RouteRef } from './routing.extensions';
+import { RuleRef } from './rule.extensions';
+import { ActionRef } from './action.extensions';
+
+export interface ExtensionConfig {
+    $name: string;
+    $version: string;
+    $description?: string;
+    $references?: Array<string>;
+
+    rules?: Array<RuleRef>;
+    routes?: Array<RouteRef>;
+    actions?: Array<ActionRef>;
+
+    features?: {
+        [key: string]: any;
+    };
+}

projects/adf-extensions/src/lib/config/navbar.extensions.ts

@@ -0,0 +1,31 @@
+/*!
+ * @license
+ * Copyright 2016 - 2018 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { ExtensionElement } from './extension-element';
+
+export interface NavBarGroupRef extends ExtensionElement {
+    items: Array<NavBarLinkRef>;
+}
+
+export interface NavBarLinkRef extends ExtensionElement {
+    icon: string;
+    title: string;
+    route: string;
+
+    url?: string; // evaluated at runtime based on route ref
+    description?: string;
+}

projects/adf-extensions/src/lib/config/permission.extensions.ts

@@ -0,0 +1,20 @@
+/*!
+ * @license
+ * Copyright 2016 - 2018 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export interface NodePermissions {
+    check(source: any, permissions: string[], options?: any): boolean;
+}

projects/adf-extensions/src/lib/config/routing.extensions.ts

@@ -0,0 +1,26 @@
+/*!
+ * @license
+ * Copyright 2016 - 2018 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export interface RouteRef {
+    id: string;
+    path: string;
+    component: string;
+
+    layout?: string;
+    auth?: string[];
+    data?: { [key: string]: string };
+}

projects/adf-extensions/src/lib/config/rule.extensions.ts

@@ -0,0 +1,44 @@
+/*!
+ * @license
+ * Copyright 2016 - 2018 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { SelectionState } from '../store/states/selection.state';
+import { NavigationState } from '../store/states/navigation.state';
+import { NodePermissions } from './permission.extensions';
+import { ProfileState } from '../store/states/profile.state';
+
+export type RuleEvaluator = (context: RuleContext, ...args: any[]) => boolean;
+
+export interface RuleContext {
+    selection: SelectionState;
+    navigation: NavigationState;
+    profile: ProfileState;
+    permissions: NodePermissions;
+
+    getEvaluator(key: string): RuleEvaluator;
+}
+
+export class RuleRef {
+    type: string;
+    id?: string;
+    parameters?: Array<RuleParameter>;
+}
+
+export interface RuleParameter {
+    type: string;
+    value: any;
+    parameters?: Array<RuleParameter>;
+}

projects/adf-extensions/src/lib/config/sidebar.extensions.ts

@@ -0,0 +1,29 @@
+/*!
+ * @license
+ * Copyright 2016 - 2018 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { ExtensionElement } from './extension-element';
+
+export interface SidebarTabRef extends ExtensionElement {
+    title: string;
+    component: string;
+
+    icon?: string;
+    rules?: {
+        visible?: string;
+        [key: string]: string;
+    };
+}

projects/adf-extensions/src/lib/config/viewer.extensions.ts

@@ -0,0 +1,23 @@
+/*!
+ * @license
+ * Copyright 2016 - 2018 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { ExtensionElement } from './extension-element';
+
+export interface ViewerExtensionRef extends ExtensionElement {
+    fileExtension: string;
+    component: string;
+}

projects/adf-extensions/src/lib/evaluators/core.evaluators.ts

@@ -0,0 +1,63 @@
+/*!
+ * @license
+ * Copyright 2016 - 2018 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { RuleContext, RuleParameter } from '../config/rule.extensions';
+
+export function not(context: RuleContext, ...args: RuleParameter[]): boolean {
+    if (!args || args.length === 0) {
+        return false;
+    }
+
+    return args
+        .every(arg => {
+            const evaluator = context.getEvaluator(arg.value);
+            if (!evaluator) {
+                console.warn('evaluator not found: ' + arg.value);
+            }
+            return !evaluator(context, ...(arg.parameters || []));
+        });
+}
+
+export function every(context: RuleContext, ...args: RuleParameter[]): boolean {
+    if (!args || args.length === 0) {
+        return false;
+    }
+
+    return args
+        .every(arg => {
+            const evaluator = context.getEvaluator(arg.value);
+            if (!evaluator) {
+                console.warn('evaluator not found: ' + arg.value);
+            }
+            return evaluator(context, ...(arg.parameters || []));
+        });
+}
+
+export function some(context: RuleContext, ...args: RuleParameter[]): boolean {
+    if (!args || args.length === 0) {
+        return false;
+    }
+
+    return args
+        .some(arg => {
+            const evaluator = context.getEvaluator(arg.value);
+            if (!evaluator) {
+                console.warn('evaluator not found: ' + arg.value);
+            }
+            return evaluator(context, ...(arg.parameters || []));
+        });
+}

projects/adf-extensions/src/lib/extensions.module.ts

@@ -0,0 +1,42 @@
+/*!
+ * @license
+ * Copyright 2016 - 2018 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { NgModule, ModuleWithProviders } from '@angular/core';
+import { ExtensionLoaderService } from './services/extension-loader.service';
+import { ExtensionService } from './services/extension.service';
+import { DynamicExtensionComponent } from './components/dynamic-component/dynamic.component';
+import { DynamicTabComponent } from './components/dynamic-tab/dynamic-tab.component';
+
+@NgModule({
+    imports: [],
+    declarations: [DynamicExtensionComponent, DynamicTabComponent],
+    exports: [DynamicExtensionComponent, DynamicTabComponent]
+})
+export class ExtensionsModule {
+    static forRoot(): ModuleWithProviders {
+        return {
+            ngModule: ExtensionsModule,
+            providers: [ExtensionLoaderService, ExtensionService]
+        };
+    }
+
+    static forChild(): ModuleWithProviders {
+        return {
+            ngModule: ExtensionsModule
+        };
+    }
+}

projects/adf-extensions/src/lib/services/extension-loader.service.ts

@@ -0,0 +1,140 @@
+/*!
+ * @license
+ * Copyright 2016 - 2018 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { ActionRef, ContentActionRef, ContentActionType } from '../config/action.extensions';
+import { ExtensionElement } from '../config/extension-element';
+import { filterEnabled, getValue, mergeObjects, sortByOrder } from '../config/extension-utils';
+import { ExtensionConfig } from '../config/extension.config';
+import { RouteRef } from '../config/routing.extensions';
+import { RuleRef } from '../config/rule.extensions';
+
+@Injectable({
+    providedIn: 'root'
+})
+export class ExtensionLoaderService {
+    constructor(private http: HttpClient) {}
+
+    load(configPath: string, pluginsPath: string): Promise<ExtensionConfig> {
+        return new Promise<any>(resolve => {
+            this.loadConfig(configPath, 0).then(result => {
+                let config = result.config;
+
+                const override = sessionStorage.getItem('aca.extension.config');
+                if (override) {
+                    console.log('overriding extension config');
+                    config = JSON.parse(override);
+                }
+
+                const externalPlugins =
+                    localStorage.getItem('experimental.external-plugins') ===
+                    'true';
+
+                if (
+                    externalPlugins &&
+                    config.$references &&
+                    config.$references.length > 0
+                ) {
+                    const plugins = config.$references.map((name, idx) =>
+                        this.loadConfig(`${pluginsPath}/${name}`, idx)
+                    );
+
+                    Promise.all(plugins).then(results => {
+                        const configs = results
+                            .filter(entry => entry)
+                            .sort(sortByOrder)
+                            .map(entry => entry.config);
+
+                        if (configs.length > 0) {
+                            config = mergeObjects(config, ...configs);
+                        }
+
+                        resolve(config);
+                    });
+                } else {
+                    resolve(config);
+                }
+            });
+        });
+    }
+
+    protected loadConfig(
+        url: string,
+        order: number
+    ): Promise<{ order: number; config: ExtensionConfig }> {
+        return new Promise(resolve => {
+            this.http.get<ExtensionConfig>(url).subscribe(
+                config => {
+                    resolve({
+                        order,
+                        config
+                    });
+                },
+                error => {
+                    console.log(error);
+                    resolve(null);
+                }
+            );
+        });
+    }
+
+    getElements<T extends ExtensionElement>(
+        config: ExtensionConfig,
+        key: string,
+        fallback: Array<T> = []
+    ): Array<T> {
+        const values = getValue(config, key) || fallback || [];
+        return values.filter(filterEnabled).sort(sortByOrder);
+    }
+
+    getContentActions(
+        config: ExtensionConfig,
+        key: string
+    ): Array<ContentActionRef> {
+        return this.getElements(config, key).map(this.setActionDefaults);
+    }
+
+    getRules(config: ExtensionConfig): Array<RuleRef> {
+        if (config && config.rules) {
+            return config.rules;
+        }
+        return [];
+    }
+
+    getRoutes(config: ExtensionConfig): Array<RouteRef> {
+        if (config) {
+            return config.routes || [];
+        }
+        return [];
+    }
+
+    getActions(config: ExtensionConfig): Array<ActionRef> {
+        if (config) {
+            return config.actions || [];
+        }
+        return [];
+    }
+
+    protected setActionDefaults(action: ContentActionRef): ContentActionRef {
+        if (action) {
+            action.type = action.type || ContentActionType.default;
+            action.icon = action.icon || 'extension';
+        }
+        return action;
+    }
+}

projects/adf-extensions/src/lib/services/extension.service.ts

@@ -0,0 +1,148 @@
+/*!
+ * @license
+ * Copyright 2016 - 2018 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Injectable, Type } from '@angular/core';
+import { RuleEvaluator, RuleRef, RuleContext, RuleParameter } from '../config/rule.extensions';
+import { ExtensionConfig } from '../config/extension.config';
+import { ExtensionLoaderService } from './extension-loader.service';
+import { RouteRef } from '../config/routing.extensions';
+import { ActionRef } from '../config/action.extensions';
+import * as core from '../evaluators/core.evaluators';
+
+@Injectable()
+export class ExtensionService {
+    configPath = 'assets/app.extensions.json';
+    pluginsPath = 'assets/plugins';
+
+    rules: Array<RuleRef> = [];
+    routes: Array<RouteRef> = [];
+    actions: Array<ActionRef> = [];
+
+    authGuards: { [key: string]: Type<{}> } = {};
+    components: { [key: string]: Type<{}> } = {};
+    evaluators: { [key: string]: RuleEvaluator } = {};
+
+    constructor(private loader: ExtensionLoaderService) {}
+
+    async load(): Promise<ExtensionConfig> {
+        const config = await this.loader.load(
+            this.configPath,
+            this.pluginsPath
+        );
+        this.setup(config);
+        return config;
+    }
+
+    setup(config: ExtensionConfig) {
+        if (!config) {
+            console.error('Extension configuration not found');
+            return;
+        }
+
+        this.setEvaluators({
+            'core.every': core.every,
+            'core.some': core.some,
+            'core.not': core.not
+        });
+
+        this.rules = this.loader.getRules(config);
+        this.actions = this.loader.getActions(config);
+        this.routes = this.loader.getRoutes(config);
+    }
+
+    setEvaluators(values: { [key: string]: RuleEvaluator }) {
+        if (values) {
+            this.evaluators = Object.assign({}, this.evaluators, values);
+        }
+    }
+
+    setAuthGuards(values: { [key: string]: Type<{}> }) {
+        if (values) {
+            this.authGuards = Object.assign({}, this.authGuards, values);
+        }
+    }
+
+    setComponents(values: { [key: string]: Type<{}> }) {
+        if (values) {
+            this.components = Object.assign({}, this.components, values);
+        }
+    }
+
+    getRouteById(id: string): RouteRef {
+        return this.routes.find(route => route.id === id);
+    }
+
+    getAuthGuards(ids: string[]): Array<Type<{}>> {
+        return (ids || [])
+            .map(id => this.authGuards[id])
+            .filter(guard => guard);
+    }
+
+    getActionById(id: string): ActionRef {
+        return this.actions.find(action => action.id === id);
+    }
+
+    getEvaluator(key: string): RuleEvaluator {
+        if (key && key.startsWith('!')) {
+            const fn = this.evaluators[key.substring(1)];
+            return (context: RuleContext, ...args: RuleParameter[]): boolean => {
+                return !fn(context, ...args);
+            };
+        }
+        return this.evaluators[key];
+    }
+
+    evaluateRule(ruleId: string, context: RuleContext): boolean {
+        const ruleRef = this.getRuleById(ruleId);
+
+        if (ruleRef) {
+            const evaluator = this.getEvaluator(ruleRef.type);
+            if (evaluator) {
+                return evaluator(context, ...ruleRef.parameters);
+            }
+        } else {
+            const evaluator = this.getEvaluator(ruleId);
+            if (evaluator) {
+                return evaluator(context);
+            }
+        }
+        return false;
+    }
+
+    getComponentById(id: string): Type<{}> {
+        return this.components[id];
+    }
+
+    getRuleById(id: string): RuleRef {
+        return this.rules.find(ref => ref.id === id);
+    }
+
+    runExpression(value: string, context?: any) {
+        const pattern = new RegExp(/\$\((.*\)?)\)/g);
+        const matches = pattern.exec(value);
+
+        if (matches && matches.length > 1) {
+            const expression = matches[1];
+            const fn = new Function('context', `return ${expression}`);
+            const result = fn(context);
+
+            return result;
+        }
+
+        return value;
+    }
+}

projects/adf-extensions/src/lib/store/states/navigation.state.ts

@@ -0,0 +1,23 @@
+/*!
+ * @license
+ * Copyright 2016 - 2018 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Node } from 'alfresco-js-api';
+
+export interface NavigationState {
+    currentFolder?: Node;
+    url?: string;
+}

projects/adf-extensions/src/lib/store/states/profile.state.ts

@@ -0,0 +1,25 @@
+/*!
+ * @license
+ * Copyright 2016 - 2018 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export interface ProfileState {
+    id: string;
+    isAdmin: boolean;
+    firstName: string;
+    lastName: string;
+    userName?: string;
+    initials?: string;
+}

projects/adf-extensions/src/lib/store/states/selection.state.ts

@@ -0,0 +1,30 @@
+/*!
+ * @license
+ * Copyright 2016 - 2018 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { MinimalNodeEntity, SiteEntry } from 'alfresco-js-api';
+
+export interface SelectionState {
+    count: number;
+    nodes: MinimalNodeEntity[];
+    libraries: SiteEntry[];
+    isEmpty: boolean;
+    first?: MinimalNodeEntity;
+    last?: MinimalNodeEntity;
+    folder?: MinimalNodeEntity;
+    file?: MinimalNodeEntity;
+    library?: SiteEntry;
+}

projects/adf-extensions/src/public_api.ts

@@ -0,0 +1,36 @@
+/*!
+ * @license
+ * Copyright 2016 - 2018 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export * from './lib/config/action.extensions';
+export * from './lib/config/extension-element';
+export * from './lib/config/extension-utils';
+export * from './lib/config/extension.config';
+export * from './lib/config/navbar.extensions';
+export * from './lib/config/permission.extensions';
+export * from './lib/config/routing.extensions';
+export * from './lib/config/rule.extensions';
+export * from './lib/config/sidebar.extensions';
+export * from './lib/config/viewer.extensions';
+
+export * from './lib/services/extension-loader.service';
+export * from './lib/services/extension.service';
+
+export * from './lib/store/states/navigation.state';
+export * from './lib/store/states/profile.state';
+export * from './lib/store/states/selection.state';
+
+export * from './lib/extensions.module';

projects/adf-extensions/src/test.ts

@@ -0,0 +1,22 @@
+// This file is required by karma.conf.js and loads recursively all the .spec and framework files
+
+import 'core-js/es7/reflect';
+import 'zone.js/dist/zone';
+import 'zone.js/dist/zone-testing';
+import { getTestBed } from '@angular/core/testing';
+import {
+  BrowserDynamicTestingModule,
+  platformBrowserDynamicTesting
+} from '@angular/platform-browser-dynamic/testing';
+
+declare const require: any;
+
+// First, initialize the Angular testing environment.
+getTestBed().initTestEnvironment(
+  BrowserDynamicTestingModule,
+  platformBrowserDynamicTesting()
+);
+// Then we find all the tests.
+const context = require.context('./', true, /\.spec\.ts$/);
+// And load the modules.
+context.keys().map(context);

projects/adf-extensions/tsconfig.lib.json

@@ -0,0 +1,33 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../out-tsc/lib",
+    "target": "es2015",
+    "module": "es2015",
+    "moduleResolution": "node",
+    "declaration": true,
+    "sourceMap": true,
+    "inlineSources": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "importHelpers": true,
+    "types": [],
+    "lib": [
+      "dom",
+      "es2015"
+    ]
+  },
+  "angularCompilerOptions": {
+    "annotateForClosureCompiler": true,
+    "skipTemplateCodegen": true,
+    "strictMetadataEmit": true,
+    "fullTemplateTypeCheck": true,
+    "strictInjectionParameters": true,
+    "flatModuleId": "AUTOGENERATED",
+    "flatModuleOutFile": "AUTOGENERATED"
+  },
+  "exclude": [
+    "src/test.ts",
+    "**/*.spec.ts"
+  ]
+}

projects/adf-extensions/tsconfig.spec.json

@@ -0,0 +1,17 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../out-tsc/spec",
+    "types": [
+      "jasmine",
+      "node"
+    ]
+  },
+  "files": [
+    "src/test.ts"
+  ],
+  "include": [
+    "**/*.spec.ts",
+    "**/*.d.ts"
+  ]
+}

projects/adf-extensions/tslint.json

@@ -0,0 +1,17 @@
+{
+    "extends": "../../tslint.json",
+    "rules": {
+        "directive-selector": [
+            true,
+            "attribute",
+            "adf",
+            "camelCase"
+        ],
+        "component-selector": [
+            true,
+            "element",
+            "adf",
+            "kebab-case"
+        ]
+    }
+}