@umbraco-cms/backoffice 16.1.1 → 16.2.0-rc2

package/dist-cms/external/openid/src/authorization_request_handler.js

@@ -0,0 +1,107 @@
+/* eslint-disable local-rules/umb-class-prefix */
+/*
+ * Copyright 2017 Google Inc.
+ *
+ * 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 { log } from './logger.js';
+/**
+ * Authorization Service notifier.
+ * This manages the communication of the AuthorizationResponse to the 3p client.
+ */
+export class AuthorizationNotifier {
+    constructor() {
+        this.listener = null;
+    }
+    setAuthorizationListener(listener) {
+        this.listener = listener;
+    }
+    /**
+     * The authorization complete callback.
+     */
+    onAuthorizationComplete(request, response, error) {
+        if (this.listener) {
+            // complete authorization request
+            this.listener(request, response, error);
+        }
+    }
+}
+// TODO(rahulrav@): add more built in parameters.
+/* built in parameters. */
+export const BUILT_IN_PARAMETERS = ['redirect_uri', 'client_id', 'response_type', 'state', 'scope'];
+/**
+ * Defines the interface which is capable of handling an authorization request
+ * using various methods (iframe / popup / different process etc.).
+ */
+export class AuthorizationRequestHandler {
+    constructor(utils, crypto) {
+        this.utils = utils;
+        this.crypto = crypto;
+        // notifier send the response back to the client.
+        this.notifier = null;
+    }
+    /**
+     * A utility method to be able to build the authorization request URL.
+     */
+    buildRequestUrl(configuration, request) {
+        // build the query string
+        // coerce to any type for convenience
+        const requestMap = {
+            redirect_uri: request.redirectUri,
+            client_id: request.clientId,
+            response_type: request.responseType,
+            state: request.state,
+            scope: request.scope,
+        };
+        // copy over extras
+        if (request.extras) {
+            for (const extra in request.extras) {
+                if (Object.prototype.hasOwnProperty.call(request.extras, extra)) {
+                    // check before inserting to requestMap
+                    if (BUILT_IN_PARAMETERS.indexOf(extra) < 0) {
+                        requestMap[extra] = request.extras[extra];
+                    }
+                }
+            }
+        }
+        const query = this.utils.stringify(requestMap);
+        const baseUrl = configuration.authorizationEndpoint;
+        const url = `${baseUrl}?${query}`;
+        return url;
+    }
+    /**
+     * Completes the authorization request if necessary & when possible.
+     */
+    completeAuthorizationRequestIfPossible() {
+        // call complete authorization if possible to see there might
+        // be a response that needs to be delivered.
+        log(`Checking to see if there is an authorization response to be delivered.`);
+        if (!this.notifier) {
+            log(`Notifier is not present on AuthorizationRequest handler.
+          No delivery of result will be possible`);
+        }
+        return this.completeAuthorizationRequest().then((result) => {
+            if (!result) {
+                log(`No result is available yet.`);
+            }
+            if (result && this.notifier) {
+                this.notifier.onAuthorizationComplete(result.request, result.response, result.error);
+            }
+        });
+    }
+    /**
+     * Sets the default Authorization Service notifier.
+     */
+    setAuthorizationNotifier(notifier) {
+        this.notifier = notifier;
+        return this;
+    }
+}

package/dist-cms/external/openid/src/authorization_response.js

@@ -0,0 +1,49 @@
+/* eslint-disable local-rules/umb-class-prefix */
+/*
+ * Copyright 2017 Google Inc.
+ *
+ * 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.
+ */
+/**
+ * Represents the Authorization Response type.
+ * For more information look at
+ * https://tools.ietf.org/html/rfc6749#section-4.1.2
+ */
+export class AuthorizationResponse {
+    constructor(response) {
+        this.code = response.code;
+        this.state = response.state;
+    }
+    toJson() {
+        return { code: this.code, state: this.state };
+    }
+}
+/**
+ * Represents the Authorization error response.
+ * For more information look at:
+ * https://tools.ietf.org/html/rfc6749#section-4.1.2.1
+ */
+export class AuthorizationError {
+    constructor(error) {
+        this.error = error.error;
+        this.errorDescription = error.error_description;
+        this.errorUri = error.error_uri;
+        this.state = error.state;
+    }
+    toJson() {
+        return {
+            error: this.error,
+            error_description: this.errorDescription,
+            error_uri: this.errorUri,
+            state: this.state,
+        };
+    }
+}

package/dist-cms/external/openid/src/authorization_service_configuration.js

@@ -0,0 +1,55 @@
+/* eslint-disable local-rules/umb-class-prefix */
+/*
+ * Copyright 2017 Google Inc.
+ *
+ * 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 { FetchRequestor } from './xhr.js';
+/**
+ * The standard base path for well-known resources on domains.
+ * See https://tools.ietf.org/html/rfc5785 for more information.
+ */
+const WELL_KNOWN_PATH = '.well-known';
+/**
+ * The standard resource under the well known path at which an OpenID Connect
+ * discovery document can be found under an issuer's base URI.
+ */
+const OPENID_CONFIGURATION = 'openid-configuration';
+/**
+ * Configuration details required to interact with an authorization service.
+ *
+ * More information at https://openid.net/specs/openid-connect-discovery-1_0-17.html
+ */
+export class AuthorizationServiceConfiguration {
+    constructor(request) {
+        this.authorizationEndpoint = request.authorization_endpoint;
+        this.tokenEndpoint = request.token_endpoint;
+        this.revocationEndpoint = request.revocation_endpoint;
+        this.userInfoEndpoint = request.userinfo_endpoint;
+        this.endSessionEndpoint = request.end_session_endpoint;
+    }
+    toJson() {
+        return {
+            authorization_endpoint: this.authorizationEndpoint,
+            token_endpoint: this.tokenEndpoint,
+            revocation_endpoint: this.revocationEndpoint,
+            end_session_endpoint: this.endSessionEndpoint,
+            userinfo_endpoint: this.userInfoEndpoint,
+        };
+    }
+    static fetchFromIssuer(openIdIssuerUrl, requestor) {
+        const fullUrl = `${openIdIssuerUrl}/${WELL_KNOWN_PATH}/${OPENID_CONFIGURATION}`;
+        const requestorToUse = requestor || new FetchRequestor();
+        return requestorToUse
+            .xhr({ url: fullUrl, dataType: 'json', method: 'GET' })
+            .then((json) => new AuthorizationServiceConfiguration(json));
+    }
+}

package/dist-cms/external/openid/src/base64-js/index.js

@@ -0,0 +1,124 @@
+/*
+ * This Source Code has been derived from base64-js.
+ * https://github.com/beatgammit/base64-js
+ * Copyright © 2014 Jameson Little
+ * Copyright © 2024 Umbraco A/S
+ * Licensed under the MIT License.
+ */
+const lookup = [];
+const revLookup = [];
+const Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array;
+const code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+for (var i = 0, len = code.length; i < len; ++i) {
+    lookup[i] = code[i];
+    revLookup[code.charCodeAt(i)] = i;
+}
+// Support decoding URL-safe base64 strings, as Node.js does.
+// See: https://en.wikipedia.org/wiki/Base64#URL_applications
+revLookup['-'.charCodeAt(0)] = 62;
+revLookup['_'.charCodeAt(0)] = 63;
+function getLens(b64) {
+    var len = b64.length;
+    if (len % 4 > 0) {
+        throw new Error('Invalid string. Length must be a multiple of 4');
+    }
+    // Trim off extra bytes after placeholder bytes are found
+    // See: https://github.com/beatgammit/base64-js/issues/42
+    var validLen = b64.indexOf('=');
+    if (validLen === -1)
+        validLen = len;
+    var placeHoldersLen = validLen === len ? 0 : 4 - (validLen % 4);
+    return [validLen, placeHoldersLen];
+}
+/**
+ * Get the byte length of a base64 string
+ * base64 is 4/3 + up to two characters of the original data
+ * @param {string} b64 - The base64 string to get the byte length of
+ * @returns {number} - The byte length
+ */
+export function byteLength(b64) {
+    var lens = getLens(b64);
+    var validLen = lens[0];
+    var placeHoldersLen = lens[1];
+    return ((validLen + placeHoldersLen) * 3) / 4 - placeHoldersLen;
+}
+function _byteLength(b64, validLen, placeHoldersLen) {
+    return ((validLen + placeHoldersLen) * 3) / 4 - placeHoldersLen;
+}
+/**
+ * Convert a base64 string to a byte array
+ * @param {string} b64 - The base64 string to convert
+ * @returns {Uint8Array} - The byte array
+ */
+export function toByteArray(b64) {
+    var tmp;
+    var lens = getLens(b64);
+    var validLen = lens[0];
+    var placeHoldersLen = lens[1];
+    var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
+    var curByte = 0;
+    // if there are placeholders, only get up to the last complete 4 chars
+    var len = placeHoldersLen > 0 ? validLen - 4 : validLen;
+    var i;
+    for (i = 0; i < len; i += 4) {
+        tmp =
+            (revLookup[b64.charCodeAt(i)] << 18) |
+                (revLookup[b64.charCodeAt(i + 1)] << 12) |
+                (revLookup[b64.charCodeAt(i + 2)] << 6) |
+                revLookup[b64.charCodeAt(i + 3)];
+        arr[curByte++] = (tmp >> 16) & 0xff;
+        arr[curByte++] = (tmp >> 8) & 0xff;
+        arr[curByte++] = tmp & 0xff;
+    }
+    if (placeHoldersLen === 2) {
+        tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4);
+        arr[curByte++] = tmp & 0xff;
+    }
+    if (placeHoldersLen === 1) {
+        tmp =
+            (revLookup[b64.charCodeAt(i)] << 10) |
+                (revLookup[b64.charCodeAt(i + 1)] << 4) |
+                (revLookup[b64.charCodeAt(i + 2)] >> 2);
+        arr[curByte++] = (tmp >> 8) & 0xff;
+        arr[curByte++] = tmp & 0xff;
+    }
+    return arr;
+}
+function tripletToBase64(num) {
+    return lookup[(num >> 18) & 0x3f] + lookup[(num >> 12) & 0x3f] + lookup[(num >> 6) & 0x3f] + lookup[num & 0x3f];
+}
+function encodeChunk(uint8, start, end) {
+    var tmp;
+    var output = [];
+    for (var i = start; i < end; i += 3) {
+        tmp = ((uint8[i] << 16) & 0xff0000) + ((uint8[i + 1] << 8) & 0xff00) + (uint8[i + 2] & 0xff);
+        output.push(tripletToBase64(tmp));
+    }
+    return output.join('');
+}
+/**
+ * Convert a byte array to a base64 string
+ * @param {Uint8Array} uint8 - The byte array to convert
+ * @returns {string} - The base64 string
+ */
+export function fromByteArray(uint8) {
+    var tmp;
+    var len = uint8.length;
+    var extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes
+    var parts = [];
+    var maxChunkLength = 16383; // must be multiple of 3
+    // go through the array every three bytes, we'll deal with trailing stuff later
+    for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
+        parts.push(encodeChunk(uint8, i, i + maxChunkLength > len2 ? len2 : i + maxChunkLength));
+    }
+    // pad the end with zeros, but make sure to not forget the extra bytes
+    if (extraBytes === 1) {
+        tmp = uint8[len - 1];
+        parts.push(lookup[tmp >> 2] + lookup[(tmp << 4) & 0x3f] + '==');
+    }
+    else if (extraBytes === 2) {
+        tmp = (uint8[len - 2] << 8) + uint8[len - 1];
+        parts.push(lookup[tmp >> 10] + lookup[(tmp >> 4) & 0x3f] + lookup[(tmp << 2) & 0x3f] + '=');
+    }
+    return parts.join('');
+}

package/dist-cms/external/openid/src/crypto_utils.js

@@ -0,0 +1,74 @@
+/* eslint-disable local-rules/umb-class-prefix */
+/*
+ * Copyright 2017 Google Inc.
+ *
+ * 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 { fromByteArray } from './base64-js/index.js';
+import { AppAuthError } from './errors.js';
+const HAS_CRYPTO = typeof window !== 'undefined' && !!window.crypto;
+const HAS_SUBTLE_CRYPTO = HAS_CRYPTO && !!window.crypto.subtle;
+const CHARSET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+export function bufferToString(buffer) {
+    const state = [];
+    for (let i = 0; i < buffer.byteLength; i += 1) {
+        const index = buffer[i] % CHARSET.length;
+        state.push(CHARSET[index]);
+    }
+    return state.join('');
+}
+export function urlSafe(buffer) {
+    const encoded = fromByteArray(new Uint8Array(buffer));
+    return encoded.replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
+}
+// adapted from source: http://stackoverflow.com/a/11058858
+// this is used in place of TextEncode as the api is not yet
+// well supported: https://caniuse.com/#search=TextEncoder
+export function textEncodeLite(str) {
+    const buf = new ArrayBuffer(str.length);
+    const bufView = new Uint8Array(buf);
+    for (let i = 0; i < str.length; i++) {
+        bufView[i] = str.charCodeAt(i);
+    }
+    return bufView;
+}
+/**
+ * The default implementation of the `Crypto` interface.
+ * This uses the capabilities of the browser.
+ */
+export class DefaultCrypto {
+    generateRandom(size) {
+        const buffer = new Uint8Array(size);
+        if (HAS_CRYPTO) {
+            window.crypto.getRandomValues(buffer);
+        }
+        else {
+            // fall back to Math.random() if nothing else is available
+            for (let i = 0; i < size; i += 1) {
+                buffer[i] = (Math.random() * CHARSET.length) | 0;
+            }
+        }
+        return bufferToString(buffer);
+    }
+    deriveChallenge(code) {
+        if (code.length < 43 || code.length > 128) {
+            return Promise.reject(new AppAuthError('Invalid code length.'));
+        }
+        if (!HAS_SUBTLE_CRYPTO) {
+            return Promise.reject(new AppAuthError('window.crypto.subtle is unavailable.'));
+        }
+        return new Promise((resolve, reject) => {
+            crypto.subtle.digest('SHA-256', textEncodeLite(code)).then((buffer) => {
+                return resolve(urlSafe(new Uint8Array(buffer)));
+            }, (error) => reject(error));
+        });
+    }
+}

package/dist-cms/external/openid/src/errors.js

@@ -0,0 +1,23 @@
+/* eslint-disable local-rules/umb-class-prefix */
+/*
+ * Copyright 2017 Google Inc.
+ *
+ * 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.
+ */
+/**
+ * Represents the AppAuthError type.
+ */
+export class AppAuthError {
+    constructor(message, extras) {
+        this.message = message;
+        this.extras = extras;
+    }
+}

package/dist-cms/external/openid/src/flags.js

@@ -0,0 +1,18 @@
+/*
+ * Copyright 2017 Google Inc.
+ *
+ * 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.
+ */
+/* Global flags that control the behavior of App Auth JS. */
+/* Logging turned on ? */
+export const IS_LOG = true;
+/* Profiling turned on ? */
+export const IS_PROFILE = false;

package/dist-cms/external/openid/src/index.d.ts

@@ -0,0 +1,17 @@
+export * from './authorization_request.js';
+export * from './authorization_request_handler.js';
+export * from './authorization_response.js';
+export * from './authorization_service_configuration.js';
+export * from './crypto_utils.js';
+export * from './errors.js';
+export * from './flags.js';
+export * from './logger.js';
+export * from './query_string_utils.js';
+export * from './redirect_based_handler.js';
+export * from './revoke_token_request.js';
+export * from './storage.js';
+export * from './token_request.js';
+export * from './token_request_handler.js';
+export * from './token_response.js';
+export type * from './types.js';
+export * from './xhr.js';

package/dist-cms/external/openid/src/index.js

@@ -0,0 +1,16 @@
+export * from './authorization_request.js';
+export * from './authorization_request_handler.js';
+export * from './authorization_response.js';
+export * from './authorization_service_configuration.js';
+export * from './crypto_utils.js';
+export * from './errors.js';
+export * from './flags.js';
+export * from './logger.js';
+export * from './query_string_utils.js';
+export * from './redirect_based_handler.js';
+export * from './revoke_token_request.js';
+export * from './storage.js';
+export * from './token_request.js';
+export * from './token_request_handler.js';
+export * from './token_response.js';
+export * from './xhr.js';

package/dist-cms/external/openid/src/logger.js

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2017 Google Inc.
+ *
+ * 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 { IS_LOG, IS_PROFILE } from './flags.js';
+export function log(message, ...args) {
+    if (IS_LOG) {
+        const length = args ? args.length : 0;
+        if (length > 0) {
+            console.log(message, ...args);
+        }
+        else {
+            console.log(message);
+        }
+    }
+}
+// check to see if native support for profiling is available.
+const NATIVE_PROFILE_SUPPORT = typeof window !== 'undefined' && !!window.performance && !!console.profile;
+/**
+ * A decorator that can profile a function.
+ */
+export function profile(target, propertyKey, descriptor) {
+    if (IS_PROFILE) {
+        return performProfile(target, propertyKey, descriptor);
+    }
+    else {
+        // return as-is
+        return descriptor;
+    }
+}
+function performProfile(target, propertyKey, descriptor) {
+    const originalCallable = descriptor.value;
+    // name must exist
+    let name = originalCallable.name;
+    if (!name) {
+        name = 'anonymous function';
+    }
+    if (NATIVE_PROFILE_SUPPORT) {
+        descriptor.value = function (args) {
+            console.profile(name);
+            const startTime = window.performance.now();
+            const result = originalCallable.call(this || window, ...args);
+            const duration = window.performance.now() - startTime;
+            console.log(`${name} took ${duration} ms`);
+            console.profileEnd();
+            return result;
+        };
+    }
+    else {
+        descriptor.value = function (args) {
+            log(`Profile start ${name}`);
+            const start = Date.now();
+            const result = originalCallable.call(this || window, ...args);
+            const duration = Date.now() - start;
+            log(`Profile end ${name} took ${duration} ms.`);
+            return result;
+        };
+    }
+    return descriptor;
+}

package/dist-cms/external/openid/src/query_string_utils.js

@@ -0,0 +1,51 @@
+/* eslint-disable local-rules/umb-class-prefix */
+/*
+ * Copyright 2017 Google Inc.
+ *
+ * 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 class BasicQueryStringUtils {
+    parse(input, useHash) {
+        if (useHash) {
+            return this.parseQueryString(input.hash);
+        }
+        else {
+            return this.parseQueryString(input.search);
+        }
+    }
+    parseQueryString(query) {
+        const result = {};
+        // if anything starts with ?, # or & remove it
+        query = query.trim().replace(/^(\?|#|&)/, '');
+        const params = query.split('&');
+        for (let i = 0; i < params.length; i += 1) {
+            const param = params[i]; // looks something like a=b
+            const parts = param.split('=');
+            if (parts.length >= 2) {
+                const key = decodeURIComponent(parts.shift());
+                const value = parts.length > 0 ? parts.join('=') : null;
+                if (value) {
+                    result[key] = decodeURIComponent(value);
+                }
+            }
+        }
+        return result;
+    }
+    stringify(input) {
+        const encoded = [];
+        for (const key in input) {
+            if (Object.prototype.hasOwnProperty.call(input, key) && input[key]) {
+                encoded.push(`${encodeURIComponent(key)}=${encodeURIComponent(input[key])}`);
+            }
+        }
+        return encoded.join('&');
+    }
+}