@kwiz/common 1.0.132 → 1.0.133

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kwiz/common",
-    "version": "1.0.132",
+    "version": "1.0.133",
     "description": "KWIZ common utilities and helpers for M365 platform",
     "main": "lib/cjs/index.js",
     "module": "lib/esm/index.js",

package/.github/workflows/npm-publish.yml

@@ -1,24 +0,0 @@
-# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
-# For more information see: https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages
-
-name: Node.js Package
-
-on:
-  push:
-    tags: 
-      - 'v*.*.*' # run every time we commit with a new version number
-
-jobs:
-  build-publish-npm:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 18
-          registry-url: https://registry.npmjs.org/
-      - run: npm ci
-      - run: npm run build
-      - run: npm publish --access public
-        env:
-          NODE_AUTH_TOKEN: ${{secrets.KWIZ_NPM_TOKEN}}

package/src/_dependencies.ts

@@ -1,13 +0,0 @@
-
-export var BuildNumber = "unset";
-export var IsLocalDev = false;
-export var ReleaseStatus = "npm";
-export function SetDependencies(params: {
-    BuildNumber?: string;
-    IsLocalDev?: boolean;
-    ReleaseStatus?: string;
-}) {
-    if (typeof params.BuildNumber === "string") BuildNumber = params.BuildNumber;
-    if (typeof params.IsLocalDev === "boolean") IsLocalDev = params.IsLocalDev;
-    if (typeof params.ReleaseStatus === "string") ReleaseStatus = params.ReleaseStatus;
-}

package/src/config.ts

@@ -1,19 +0,0 @@
-import { SetDependencies } from './_dependencies';
-import { ConsoleLogger } from './utils/consolelogger';
-
-export function config(params: {
-    BuildNumber?: string;
-    IsLocalDev?: boolean;
-    ReleaseStatus?: string;
-    ProjectName?: string;
-}) {
-    SetDependencies(params);
-    function GetLogger(name: string) {
-        return ConsoleLogger.get(name, params.ProjectName);
-    }
-    return {
-        GetLogger,
-        /** @deprecated exported as GetLogger, which is how is used anyways  */
-        logger: GetLogger
-    }
-}

package/src/exports-index.ts

@@ -1,4 +0,0 @@
-export * from './helpers/exports-index';
-export * from './types/exports-index';
-export * from './utils/exports-index';
-export * from './config';

package/src/helpers/Guid.ts

@@ -1,182 +0,0 @@
-/**
- * This class represents a globally unique identifier, as described by
- * IETF RFC 4122.
- *
- * @remarks
- * The input string is normalized and validated, which provides
- * important guarantees that simplify other code that works with the GUID.
- * This class also provides basic support for generating a pseudo-random GUID;
- * however, be aware that the uniqueness depends on the browser's `Math.random()`
- * function and may be not be suitable for some applications.
- *
- * See {@link https://www.ietf.org/rfc/rfc4122.txt | RFC4122} for more information.
- *
- * @public
- */
-
-import { isNullOrEmptyString, isNullOrUndefined } from "./typecheckers";
-
-export class Guid {
-    private _guid;
-    /**
-    * Returns a new empty Guid instance.
-    *
-    * @returns A new empty Guid object.
-    */
-    public static empty = new Guid('00000000-0000-0000-0000-000000000000');
-    private static _guidRegEx = /^[0-9a-f]{8}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{12}$/i;
-
-    /**
-     * Use `Guid.parse()` or `Guid.tryParse()` instead of the constructor.
-     * @param guid - a normalized, already valid Guid string
-     */
-    constructor(guid) {
-        this._guid = guid;
-    }
-    /**
-     * Returns a new Guid instance with a pseudo-randomly generated GUID, according
-     * to the version 4 UUID algorithm from RFC 4122.
-     *
-     * @returns A new unique Guid object
-     */
-    public static newGuid(randomNumberGenerator) {
-        return new Guid(Guid._generateGuid(randomNumberGenerator));
-    }
-    /**
-     * Parses the input string to construct a new Guid object.
-     * If the string cannot be parsed, then an error is thrown.
-     *
-     * @remarks
-     * Example syntaxes accepted by this function:
-     *
-     * - `"d5369f3bbd7a412a9c0f7f0650bb5489"`
-     *
-     * - `"d5369f3b-bd7a-412a-9c0f-7f0650bb5489"`
-     *
-     * - `"{d5369f3b-bd7a-412a-9c0f-7f0650bb5489}"`
-     *
-     * - `"/Guid(d5369f3b-bd7a-412a-9c0f-7f0650bb5489)/"`
-     *
-     * @param guid - The input string.
-     * @returns A valid Guid object
-     */
-    public static parse(guidString) {
-        var guid = Guid.tryParse(guidString);
-        if (!guid) {
-            throw new Error(`***Invalid GUID string: "${guidString}"`)
-        }
-        return guid;
-    }
-    /**
-     * Attempts to parse the input string to construct a new Guid object.
-     * If the string cannot be parsed, then undefined is returned.
-     *
-     * @remarks
-     * Example syntaxes accepted by this function:
-     *
-     * - `"d5369f3bbd7a412a9c0f7f0650bb5489"`
-     *
-     * - `"d5369f3b-bd7a-412a-9c0f-7f0650bb5489"`
-     *
-     * - `"{d5369f3b-bd7a-412a-9c0f-7f0650bb5489}"`
-     *
-     * - `"/Guid(d5369f3b-bd7a-412a-9c0f-7f0650bb5489)/"`
-     *
-     * @param guid - The input string.
-     * @returns The Guid object, or undefined if the string could not be parsed.
-     */
-    public static tryParse(guid) {
-        if (guid) {
-            guid = Guid._normalize(guid);
-            if (Guid._guidRegEx.test(guid)) {
-                return new Guid(guid);
-            }
-        }
-        return undefined;
-    }
-    /**
-     * Indicates whether a GUID is valid, i.e. whether it would be successfully
-     * parsed by `Guid.tryParse()`.  This function is cheaper than `Guid.tryParse()`
-     * because it does not construct a Guid object.
-     *
-     * @param guid - The input string.
-     * @returns true, if the Guid is valid.
-     */
-    public static isValid(guid) {
-        if (guid) {
-            guid = Guid._normalize(guid);
-            if (Guid._guidRegEx.test(guid)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * SharePoint can have guids in the form:
-     *   - `Guid(...)`
-     *   - `{...}`
-     * _normalize transforms guids in this format to the standard
-     * guid format.
-     *
-     * Example: `Guid(d5369f3b-bd7a-412a-9c0f-7f0650bb5489)` becomes `d5369f3b-bd7a-412a-9c0f-7f0650bb5489`
-     * Example: `{d5369f3b-bd7a-412a-9c0f-7f0650bb5489}` becomes `d5369f3b-bd7a-412a-9c0f-7f0650bb5489`
-     *
-     * @param guid - Guid to be normalized, could already be normalized.
-     * @returns Normalized guid.
-     */
-    private static _normalize(guid) {
-        if (isNullOrEmptyString(guid)) {
-            throw new Error(`***The value for "guid" must not be an empty string`)
-        }
-        // Check for Guid(...) and strip
-        var result = /^Guid\((.*)\)/i.exec(guid); /* tslint:disable-line:no-null-keyword */
-        if (result) {
-            guid = result[1];
-        }
-        // Check for and strip leading or trailing curly braces
-        if (guid.length === 38) {
-            guid = guid.substr(1, 36);
-        }
-        return guid.toLowerCase();
-    }
-    /**
-     * Creates a new guid.
-     *
-     * @returns A valid guid (according to RFC4122)
-     */
-    private static _generateGuid(randomNumberGenerator) {
-        return 'AAAAAAAA-AAAA-4AAA-BAAA-AAAAAAAAAAAA'.replace(/[AB]/g,
-            // Callback for String.replace() when generating a guid.
-            function (character) {
-                var randomNumber = randomNumberGenerator ? randomNumberGenerator.generate() : Math.random();
-                /* tslint:disable:no-bitwise */
-                var num = randomNumber * 16 | 0;
-                // Check for 'A' in template string because the first characters in the
-                // third and fourth blocks must be specific characters (according to "version 4" UUID from RFC 4122)
-                var masked = character === 'A' ? num : (num & 0x3 | 0x8);
-                return masked.toString(16);
-            });
-    }
-    /**
-     * Compare this instance to another Guid instance
-     *
-     * @returns True if this instance and the specified Guid object
-     * represent the same value.
-     */
-    public equals(guid) {
-        if (isNullOrUndefined(guid)) {
-            throw new Error(`"***The value for "guid" must not be null or undefined"`)
-        }
-        return guid && this._guid.toString() === guid.toString();
-    }
-    /**
-     * Returns a string representation of the GUID
-     *
-     * @returns The GUID value in lowercase hexadecimal without braces.
-     *
-     * Example: `'d5369f3b-bd7a-412a-9c0f-7f0650bb5489'`
-     */
-    public toString = function () {
-        return this._guid;
-    }
-}

package/src/helpers/base64.ts

@@ -1,174 +0,0 @@
-
-export async function blobToBase64(data: Blob): Promise<string> {
-    return new Promise<string>((resolve, reject) => {
-        var fileReader = new FileReader();
-        fileReader.onloadend = () => {
-            resolve(fileReader.result as string);
-        };
-        fileReader.onerror = () => {
-            reject();
-        };
-        fileReader.readAsDataURL(data);
-    });
-}
-
-/** returns true of the string is a data: with base64 content */
-export function isBase64ImageData(str: string): boolean {
-    return str.startsWith("data") && str.indexOf("base64") > 0;
-}
-
-const alphabet = [
-    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
-    'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
-    'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
-    'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
-    'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
-    'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
-    'w', 'x', 'y', 'z', '0', '1', '2', '3',
-    '4', '5', '6', '7', '8', '9', '+', '/'
-];
-
-const values = {};
-for (let i = 0; i < alphabet.length; ++i) {
-    values[alphabet[i]] = i;
-}
-
-function encode(bytes: ArrayBuffer): string {
-    const array = new Uint8Array(bytes);
-    const base64 = [];
-    let index = 0;
-    let quantum;
-    let value;
-
-    // Grab as many sets of 3 bytes as we can, that form 24 bits.
-    while (index + 2 < array.byteLength) {
-        quantum = (array[index] << 16) | (array[index + 1] << 8) | array[index + 2];
-        // 24 bits will become 4 base64 chars.
-        value = (quantum >> 18) & 0x3f;
-        base64.push(alphabet[value]);
-        value = (quantum >> 12) & 0x3f;
-        base64.push(alphabet[value]);
-        value = (quantum >> 6) & 0x3f;
-        base64.push(alphabet[value]);
-        value = quantum & 0x3f;
-        base64.push(alphabet[value]);
-        index += 3;
-    }
-    // At this point, there are 0, 1 or 2 bytes left.
-    if (index + 1 === array.byteLength) {
-        // 8 bits; shift by 4 to pad on the right with 0s to make 12 bits total.
-        quantum = array[index] << 4;
-        value = (quantum >> 6) & 0x3f;
-        base64.push(alphabet[value]);
-        value = quantum & 0x3f;
-        base64.push(alphabet[value]);
-        base64.push('==');
-    } else if (index + 2 === array.byteLength) {
-        // 16 bits; shift by 2 to pad on the right with 0s to make 18 bits total.
-        quantum = (array[index] << 10) | (array[index + 1] << 2);
-        value = (quantum >> 12) & 0x3f;
-        base64.push(alphabet[value]);
-        value = (quantum >> 6) & 0x3f;
-        base64.push(alphabet[value]);
-        value = quantum & 0x3f;
-        base64.push(alphabet[value]);
-        base64.push('=');
-    }
-    return base64.join('');
-}
-
-function decode(string: string): Uint8Array {
-    let size = string.length;
-    if (size === 0) {
-        return new Uint8Array(new ArrayBuffer(0));
-    }
-    if (size % 4 !== 0) {
-        throw new Error('Bad length: ' + size);
-    }
-    if (!string.match(/^[a-zA-Z0-9+/]+={0,2}$/)) {
-        throw new Error('Invalid base64 encoded value');
-    }
-    // Every 4 base64 chars = 24 bits = 3 bytes. But, we also need to figure out
-    // padding, if any.
-    let bytes = 3 * (size / 4);
-    let numPad = 0;
-    if (string.charAt(size - 1) === '=') {
-        numPad++;
-        bytes--;
-    }
-    if (string.charAt(size - 2) === '=') {
-        numPad++;
-        bytes--;
-    }
-    const buffer = new Uint8Array(new ArrayBuffer(bytes));
-    let index = 0;
-    let bufferIndex = 0;
-    let quantum;
-    if (numPad > 0) {
-        size -= 4; // handle the last one specially
-    }
-
-    while (index < size) {
-        quantum = 0;
-        for (let i = 0; i < 4; ++i) {
-            quantum = (quantum << 6) | values[string.charAt(index + i)];
-        }
-        // quantum is now a 24-bit value.
-        buffer[bufferIndex++] = (quantum >> 16) & 0xff;
-        buffer[bufferIndex++] = (quantum >> 8) & 0xff;
-        buffer[bufferIndex++] = quantum & 0xff;
-        index += 4;
-    }
-    if (numPad > 0) {
-        // if numPad === 1, there is one =, and we have 18 bits with 2 0s at end.
-        // if numPad === 2, there is two ==, and we have 12 bits with 4 0s at end.
-        // First, grab my quantum.
-        quantum = 0;
-        for (let i = 0; i < 4 - numPad; ++i) {
-            quantum = (quantum << 6) | values[string.charAt(index + i)];
-        }
-        if (numPad === 1) {
-            // quantum is 18 bits, but really represents two bytes.
-            quantum = quantum >> 2;
-            buffer[bufferIndex++] = (quantum >> 8) & 0xff;
-            buffer[bufferIndex++] = quantum & 0xff;
-        } else {
-            // quantum is 12 bits, but really represents only one byte.
-            quantum = quantum >> 4;
-            buffer[bufferIndex++] = quantum & 0xff;
-        }
-    }
-    return buffer;
-}
-
-export function toArrayBuffer(base64: string): ArrayBuffer {
-    var uint8Array = decode(base64);
-    return uint8Array.buffer;
-}
-
-export function toUint8Array(base64: string): Uint8Array {
-    return decode(base64);
-}
-
-export function fromArrayBuffer(arraybuffer: ArrayBuffer) {
-    return encode(arraybuffer);
-}
-
-export function fromUint8Array(uint8Array: Uint8Array) {
-    return encode(uint8Array.buffer);
-}
-
-export function dataURLtoFile(dataurl, filename): File {
-
-    var arr = dataurl.split(','),
-        mime = arr[0].match(/:(.*?);/)[1],
-        bstr = atob(arr[1]),
-        n = bstr.length,
-        u8arr = new Uint8Array(n);
-
-    while (n--) {
-        u8arr[n] = bstr.charCodeAt(n);
-    }
-
-    return new File([u8arr], filename, { type: mime });
-}

package/src/helpers/browser.test.js

@@ -1,13 +0,0 @@
-import assert from 'assert/strict';
-import test from 'node:test';
-import { DisableAnchorInterceptInHtml, HTMLDecode } from "./browser";
-
-test('DisableAnchorInterceptInHtml', async t => {
-    assert.strictEqual(DisableAnchorInterceptInHtml(`<a href="blah">test</a>`), `<a data-interception="off" href="blah">test</a>`);
-    assert.strictEqual(DisableAnchorInterceptInHtml(`<div><a href="blah">test</a><a href="blah">test</a></div>`), `<div><a data-interception="off" href="blah">test</a><a data-interception="off" href="blah">test</a></div>`);
-    assert.strictEqual(DisableAnchorInterceptInHtml(`<p href="blah">test</p>`), `<p href="blah">test</p>`);
-});
-
-test('HTMLDecode', async t => {
-    assert.strictEqual(HTMLDecode(`hello &lt; &#58;`), `hello < :`);
-});