@alfresco/aca-content 5.1.1 → 5.2.0

package/esm2022/lib/utils/aca-search-utils.mjs

@@ -0,0 +1,129 @@
+/*!
+ * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * 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
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { Buffer } from 'buffer';
+/**
+ * Checks if string is an AND or OR operator
+ *
+ * @param input string to check if it is an operator
+ * @returns boolean
+ */
+export function isOperator(input) {
+    if (input) {
+        input = input.trim().toUpperCase();
+        const operators = ['AND', 'OR'];
+        return operators.includes(input);
+    }
+    return false;
+}
+/**
+ * Formats a search term by provided fields
+ *
+ * @param term search term
+ * @param fields array of fields
+ * @returns string
+ */
+export function formatSearchTermByFields(term, fields) {
+    let prefix = '';
+    let suffix = '*';
+    if (term.startsWith('=')) {
+        prefix = '=';
+        suffix = '';
+        term = term.substring(1);
+    }
+    if (term === '*') {
+        prefix = '';
+        suffix = '';
+    }
+    return '(' + fields.map((field) => `${prefix}${field}:"${term}${suffix}"`).join(' OR ') + ')';
+}
+/**
+ * Formats a search term, splits by words, skips custom queries containing ':' or '"'
+ *
+ * @param userInput search term
+ * @param fields array of fields
+ * @returns string
+ */
+export function formatSearchTerm(userInput, fields = ['cm:name']) {
+    if (!userInput) {
+        return '';
+    }
+    userInput = userInput.trim();
+    if (userInput.includes(':') || userInput.includes('"')) {
+        return userInput;
+    }
+    const words = userInput.split(' ');
+    if (words.length > 1) {
+        const separator = words.some(isOperator) ? ' ' : ' AND ';
+        return words.map((term) => (isOperator(term) ? term : formatSearchTermByFields(term, fields))).join(separator);
+    }
+    return formatSearchTermByFields(userInput, fields);
+}
+/**
+ * Decodes a query and extracts the user query
+ *
+ * @param encodedQuery encoded query
+ * @returns string
+ */
+export function extractUserQueryFromEncodedQuery(encodedQuery) {
+    if (encodedQuery) {
+        const decodedQuery = JSON.parse(Buffer.from(encodedQuery, 'base64').toString('utf-8'));
+        return decodedQuery.userQuery;
+    }
+    return '';
+}
+/**
+ * Extracts user query from encoded query and splits it to get a search term
+ *
+ * @param encodedQuery encoded query
+ * @returns string
+ */
+export function extractSearchedWordFromEncodedQuery(encodedQuery) {
+    if (encodedQuery) {
+        const userQuery = extractUserQueryFromEncodedQuery(encodedQuery);
+        return userQuery !== '' && userQuery !== undefined
+            ? userQuery
+                .split('AND')
+                .map((searchCondition) => {
+                const searchTerm = searchCondition.split('"')[1];
+                return searchTerm === '*' ? searchTerm : searchTerm.slice(0, -1);
+            })
+                .join(' ')
+            : '';
+    }
+    return '';
+}
+/**
+ * Extracts filters configuration from encoded query
+ *
+ * @param encodedQuery encoded query
+ * @returns object containing filters configuration
+ */
+export function extractFiltersFromEncodedQuery(encodedQuery) {
+    if (encodedQuery) {
+        const decodedQuery = Buffer.from(encodedQuery, 'base64').toString('utf-8');
+        return JSON.parse(decodedQuery);
+    }
+    return null;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aca-search-utils.js","sourceRoot":"","sources":["../../../../../../projects/aca-content/src/lib/utils/aca-search-utils.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Alfresco Example Content Application\n *\n * This file is part of the Alfresco Example Content Application.\n * If the software was purchased under a paid Alfresco license, the terms of\n * the paid license agreement will prevail. Otherwise, the software is\n * provided under the following open source license terms:\n *\n * The Alfresco Example Content Application is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * The Alfresco Example Content Application is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { Buffer } from 'buffer';\n\n/**\n * Checks if string is an AND or OR operator\n *\n * @param input string to check if it is an operator\n * @returns boolean\n */\nexport function isOperator(input: string): boolean {\n  if (input) {\n    input = input.trim().toUpperCase();\n\n    const operators = ['AND', 'OR'];\n    return operators.includes(input);\n  }\n  return false;\n}\n\n/**\n * Formats a search term by provided fields\n *\n * @param term search term\n * @param fields array of fields\n * @returns string\n */\nexport function formatSearchTermByFields(term: string, fields: string[]): string {\n  let prefix = '';\n  let suffix = '*';\n\n  if (term.startsWith('=')) {\n    prefix = '=';\n    suffix = '';\n    term = term.substring(1);\n  }\n\n  if (term === '*') {\n    prefix = '';\n    suffix = '';\n  }\n\n  return '(' + fields.map((field) => `${prefix}${field}:\"${term}${suffix}\"`).join(' OR ') + ')';\n}\n\n/**\n * Formats a search term, splits by words, skips custom queries containing ':' or '\"'\n *\n * @param userInput search term\n * @param fields array of fields\n * @returns string\n */\nexport function formatSearchTerm(userInput: string, fields = ['cm:name']): string {\n  if (!userInput) {\n    return '';\n  }\n  userInput = userInput.trim();\n\n  if (userInput.includes(':') || userInput.includes('\"')) {\n    return userInput;\n  }\n\n  const words = userInput.split(' ');\n\n  if (words.length > 1) {\n    const separator = words.some(isOperator) ? ' ' : ' AND ';\n    return words.map((term) => (isOperator(term) ? term : formatSearchTermByFields(term, fields))).join(separator);\n  }\n\n  return formatSearchTermByFields(userInput, fields);\n}\n\n/**\n * Decodes a query and extracts the user query\n *\n * @param encodedQuery encoded query\n * @returns string\n */\nexport function extractUserQueryFromEncodedQuery(encodedQuery: string): string {\n  if (encodedQuery) {\n    const decodedQuery: { [key: string]: any } = JSON.parse(Buffer.from(encodedQuery, 'base64').toString('utf-8'));\n    return decodedQuery.userQuery;\n  }\n  return '';\n}\n\n/**\n * Extracts user query from encoded query and splits it to get a search term\n *\n * @param encodedQuery encoded query\n * @returns string\n */\nexport function extractSearchedWordFromEncodedQuery(encodedQuery: string): string {\n  if (encodedQuery) {\n    const userQuery = extractUserQueryFromEncodedQuery(encodedQuery);\n    return userQuery !== '' && userQuery !== undefined\n      ? userQuery\n          .split('AND')\n          .map((searchCondition) => {\n            const searchTerm = searchCondition.split('\"')[1];\n            return searchTerm === '*' ? searchTerm : searchTerm.slice(0, -1);\n          })\n          .join(' ')\n      : '';\n  }\n  return '';\n}\n\n/**\n * Extracts filters configuration from encoded query\n *\n * @param encodedQuery encoded query\n * @returns object containing filters configuration\n */\nexport function extractFiltersFromEncodedQuery(encodedQuery: string): any {\n  if (encodedQuery) {\n    const decodedQuery = Buffer.from(encodedQuery, 'base64').toString('utf-8');\n    return JSON.parse(decodedQuery);\n  }\n  return null;\n}\n"]}

package/esm2022/ms-office/actions/aos.actions.mjs

@@ -0,0 +1,32 @@
+/*!
+ * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * 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
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+export const AOS_ACTION = 'AOS_ACTION';
+export class AosAction {
+    payload;
+    type = AOS_ACTION;
+    constructor(payload) {
+        this.payload = payload;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/ms-office/aos-extension.module.mjs

@@ -0,0 +1,53 @@
+/*!
+ * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * 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
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { ExtensionService, provideExtensionConfig } from '@alfresco/adf-extensions';
+import { NgModule } from '@angular/core';
+import { EffectsModule } from '@ngrx/effects';
+import { AosEffects } from './effects/aos.effects';
+import { TranslationService } from '@alfresco/adf-core';
+import { canOpenWithOffice } from '@alfresco/aca-shared/rules';
+import * as i0 from "@angular/core";
+import * as i1 from "@alfresco/adf-extensions";
+import * as i2 from "@alfresco/adf-core";
+import * as i3 from "@ngrx/effects";
+class AosExtensionModule {
+    constructor(extensions, translation) {
+        translation.addTranslationFolder('ms-office', 'assets/ms-office');
+        extensions.setEvaluators({
+            'aos.canOpenWithOffice': canOpenWithOffice
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: AosExtensionModule, deps: [{ token: i1.ExtensionService }, { token: i2.TranslationService }], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.9", ngImport: i0, type: AosExtensionModule, imports: [i3.EffectsFeatureModule] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: AosExtensionModule, providers: [provideExtensionConfig(['aos.plugin.json'])], imports: [EffectsModule.forFeature([AosEffects])] });
+}
+export { AosExtensionModule };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: AosExtensionModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [EffectsModule.forFeature([AosEffects])],
+                    providers: [provideExtensionConfig(['aos.plugin.json'])]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ExtensionService }, { type: i2.TranslationService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/ms-office/aos-extension.service.mjs

@@ -0,0 +1,136 @@
+/*!
+ * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * 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
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+/* cspell:disable */
+import { AuthenticationService, NotificationService } from '@alfresco/adf-core';
+import { Injectable } from '@angular/core';
+import { getFileExtension, supportedExtensions } from '@alfresco/aca-shared/rules';
+import { AppSettingsService } from '@alfresco/aca-shared';
+import * as i0 from "@angular/core";
+import * as i1 from "@alfresco/adf-core";
+import * as i2 from "@alfresco/aca-shared";
+class AosEditOnlineService {
+    authenticationService;
+    appSettings;
+    notificationService;
+    constructor(authenticationService, appSettings, notificationService) {
+        this.authenticationService = authenticationService;
+        this.appSettings = appSettings;
+        this.notificationService = notificationService;
+    }
+    onActionEditOnlineAos(node) {
+        if (node && this.isFile(node) && node.properties) {
+            if (node.isLocked) {
+                // const checkedOut = node.aspectNames.find(
+                //   (aspect: string) => aspect === 'cm:checkedOut'
+                // );
+                const checkedOut = node.properties['cm:lockType'] === 'WRITE_LOCK' || node.properties['cm:lockType'] === 'READ_ONLY_LOCK';
+                const lockOwner = node.properties['cm:lockOwner'];
+                const differentLockOwner = lockOwner.id !== this.authenticationService.getEcmUsername();
+                if (checkedOut && differentLockOwner) {
+                    this.onAlreadyLockedNotification(node.id, lockOwner.id);
+                }
+                else {
+                    this.triggerEditOnlineAos(node);
+                }
+            }
+            else {
+                this.triggerEditOnlineAos(node);
+            }
+        }
+    }
+    getUserAgent() {
+        return navigator.userAgent.toLowerCase();
+    }
+    isWindows() {
+        return this.getUserAgent().indexOf('win') !== -1;
+    }
+    isMacOs() {
+        return this.getUserAgent().indexOf('mac') !== -1;
+    }
+    onAlreadyLockedNotification(nodeId, lockOwner) {
+        this.notificationService.showError(`AOS.ERRORS.ALREADY_LOCKED`, null, {
+            nodeId,
+            lockOwner
+        });
+    }
+    getProtocolForFileExtension(fileExtension) {
+        return fileExtension && supportedExtensions[fileExtension];
+    }
+    triggerEditOnlineAos(node) {
+        const aosHost = this.appSettings.aosHost;
+        let url;
+        const pathElements = (node.path?.elements || []).map((segment) => segment.name);
+        if (!pathElements.length) {
+            url = `${aosHost}/Company Home/_aos_nodeid/${this.getNodeId(node)}/${encodeURIComponent(node.name)}`;
+        }
+        if (pathElements.length === 1) {
+            url = `${aosHost}/${encodeURIComponent(node.name)}`;
+        }
+        if (pathElements.length > 1) {
+            const root = pathElements[1];
+            url = `${aosHost}/${root}/_aos_nodeid/${this.getNodeId(node)}/${encodeURIComponent(node.name)}`;
+        }
+        const fileExtension = getFileExtension(node.name);
+        const protocolHandler = this.getProtocolForFileExtension(fileExtension);
+        if (protocolHandler === undefined) {
+            this.notificationService.showError(`AOS.ERRORS.MISSING_PROTOCOL_HANDLER`, null, { nodeName: node.name });
+            return;
+        }
+        if (!this.isWindows() && !this.isMacOs()) {
+            this.notificationService.showError('AOS.ERRORS.UNSUPPORTED_PLATFORM');
+        }
+        else {
+            this.openByUrl(protocolHandler, url);
+        }
+    }
+    openByUrl(protocolHandler, url) {
+        const finalUrl = protocolHandler + ':ofe%7Cu%7C' + url;
+        const iframe = document.createElement('iframe');
+        iframe.style.display = 'none';
+        iframe.src = finalUrl;
+        document.body.appendChild(iframe);
+        setTimeout(() => {
+            if (iframe) {
+                document.body.removeChild(iframe);
+            }
+        }, 500);
+    }
+    isFile(node) {
+        const implicitFile = node.nodeId || node.guid;
+        return !!implicitFile || node.isFile;
+    }
+    getNodeId(node) {
+        return node.nodeId || node.guid || node.id;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: AosEditOnlineService, deps: [{ token: i1.AuthenticationService }, { token: i2.AppSettingsService }, { token: i1.NotificationService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: AosEditOnlineService, providedIn: 'root' });
+}
+export { AosEditOnlineService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: AosEditOnlineService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.AuthenticationService }, { type: i2.AppSettingsService }, { type: i1.NotificationService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aos-extension.service.js","sourceRoot":"","sources":["../../../../../projects/aca-content/ms-office/src/aos-extension.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Alfresco Example Content Application\n *\n * This file is part of the Alfresco Example Content Application.\n * If the software was purchased under a paid Alfresco license, the terms of\n * the paid license agreement will prevail. Otherwise, the software is\n * provided under the following open source license terms:\n *\n * The Alfresco Example Content Application is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * The Alfresco Example Content Application is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.\n */\n\n/* cspell:disable */\nimport { AuthenticationService, NotificationService } from '@alfresco/adf-core';\nimport { Injectable } from '@angular/core';\nimport { Node } from '@alfresco/js-api';\nimport { getFileExtension, supportedExtensions } from '@alfresco/aca-shared/rules';\nimport { AppSettingsService } from '@alfresco/aca-shared';\n\nexport interface IAosEditOnlineService {\n  onActionEditOnlineAos(node: Node): void;\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class AosEditOnlineService implements IAosEditOnlineService {\n  constructor(\n    private authenticationService: AuthenticationService,\n    private appSettings: AppSettingsService,\n    private notificationService: NotificationService\n  ) {}\n\n  onActionEditOnlineAos(node: Node): void {\n    if (node && this.isFile(node) && node.properties) {\n      if (node.isLocked) {\n        // const checkedOut = node.aspectNames.find(\n        //   (aspect: string) => aspect === 'cm:checkedOut'\n        // );\n        const checkedOut = node.properties['cm:lockType'] === 'WRITE_LOCK' || node.properties['cm:lockType'] === 'READ_ONLY_LOCK';\n        const lockOwner = node.properties['cm:lockOwner'];\n        const differentLockOwner = lockOwner.id !== this.authenticationService.getEcmUsername();\n\n        if (checkedOut && differentLockOwner) {\n          this.onAlreadyLockedNotification(node.id, lockOwner.id);\n        } else {\n          this.triggerEditOnlineAos(node);\n        }\n      } else {\n        this.triggerEditOnlineAos(node);\n      }\n    }\n  }\n\n  private getUserAgent(): string {\n    return navigator.userAgent.toLowerCase();\n  }\n\n  private isWindows(): boolean {\n    return this.getUserAgent().indexOf('win') !== -1;\n  }\n\n  private isMacOs(): boolean {\n    return this.getUserAgent().indexOf('mac') !== -1;\n  }\n\n  private onAlreadyLockedNotification(nodeId: string, lockOwner: string) {\n    this.notificationService.showError(`AOS.ERRORS.ALREADY_LOCKED`, null, {\n      nodeId,\n      lockOwner\n    });\n  }\n\n  private getProtocolForFileExtension(fileExtension: string) {\n    return fileExtension && supportedExtensions[fileExtension];\n  }\n\n  private triggerEditOnlineAos(node: Node): void {\n    const aosHost = this.appSettings.aosHost;\n    let url: string;\n    const pathElements = (node.path?.elements || []).map((segment) => segment.name);\n\n    if (!pathElements.length) {\n      url = `${aosHost}/Company Home/_aos_nodeid/${this.getNodeId(node)}/${encodeURIComponent(node.name)}`;\n    }\n\n    if (pathElements.length === 1) {\n      url = `${aosHost}/${encodeURIComponent(node.name)}`;\n    }\n\n    if (pathElements.length > 1) {\n      const root = pathElements[1];\n      url = `${aosHost}/${root}/_aos_nodeid/${this.getNodeId(node)}/${encodeURIComponent(node.name)}`;\n    }\n\n    const fileExtension = getFileExtension(node.name);\n    const protocolHandler = this.getProtocolForFileExtension(fileExtension);\n\n    if (protocolHandler === undefined) {\n      this.notificationService.showError(`AOS.ERRORS.MISSING_PROTOCOL_HANDLER`, null, { nodeName: node.name });\n      return;\n    }\n\n    if (!this.isWindows() && !this.isMacOs()) {\n      this.notificationService.showError('AOS.ERRORS.UNSUPPORTED_PLATFORM');\n    } else {\n      this.openByUrl(protocolHandler, url);\n    }\n  }\n\n  openByUrl(protocolHandler: string, url: string) {\n    const finalUrl = protocolHandler + ':ofe%7Cu%7C' + url;\n\n    const iframe = document.createElement('iframe');\n    iframe.style.display = 'none';\n    iframe.src = finalUrl;\n\n    document.body.appendChild(iframe);\n\n    setTimeout(() => {\n      if (iframe) {\n        document.body.removeChild(iframe);\n      }\n    }, 500);\n  }\n\n  private isFile(node: Node): boolean {\n    const implicitFile = (node as any).nodeId || (node as any).guid;\n\n    return !!implicitFile || node.isFile;\n  }\n\n  private getNodeId(node: Node): string {\n    return (node as any).nodeId || (node as any).guid || node.id;\n  }\n}\n"]}

package/esm2022/ms-office/effects/aos.effects.mjs

@@ -0,0 +1,45 @@
+/*!
+ * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * 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
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { inject, Injectable } from '@angular/core';
+import { Actions, createEffect, ofType } from '@ngrx/effects';
+import { map } from 'rxjs/operators';
+import { AOS_ACTION } from '../actions/aos.actions';
+import { AosEditOnlineService } from '../aos-extension.service';
+import * as i0 from "@angular/core";
+class AosEffects {
+    actions$ = inject(Actions);
+    aosEditOnlineService = inject(AosEditOnlineService);
+    openOffice$ = createEffect(() => this.actions$.pipe(ofType(AOS_ACTION), map((action) => {
+        if (action.payload) {
+            this.aosEditOnlineService.onActionEditOnlineAos(action.payload);
+        }
+    })), { dispatch: false });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: AosEffects, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: AosEffects });
+}
+export { AosEffects };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: AosEffects, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/public-api.mjs

@@ -0,0 +1,33 @@
+/*!
+ * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * 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
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Public API Surface of aca-content
+ */
+export * from './lib/aca-content.module';
+export * from './lib/aca-content.routes';
+export * from './lib/extensions/core.extensions.module';
+export * from './lib/store/initial-state';
+export * from './lib/services/content-url.service';
+export * from './lib/utils/aca-search-utils';
+//# sourceMappingURL=data:application/json;base64,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