@bbn/bbn 1.0.58 → 1.0.60

package/dist/fn/ajax/download.js

@@ -0,0 +1,64 @@
+import { ajax } from './ajax';
+import { substr } from '../string/substr';
+import { baseName } from '../string/baseName';
+import { isBlob } from '../type/isBlob';
+import { fileExt } from '../string/fileExt';
+import { downloadContent } from './downloadContent';
+import { defaultAjaxErrorFunction } from '../default/defaultAjaxErrorFunction';
+/**
+ * Downloads a file with given filename from a URL.
+ *
+ * Gets the file's content as Blob through XHR, then sends it to bbn.fn.downloadContent.
+ * __Attention__ The CORS policy applies
+ *
+ * @method   download
+ * @global
+ * @memberof bbn.fn
+ *
+ * @example
+ * ```javascript
+ * // Forcing the download of an image
+ * bbn.fn.download('/bbn/js-title-black.png');
+ *
+ * // Forcing the download of a PDF
+ * bbn.fn.download('/files/my-document.pdf');
+ *
+ * // Changing the name as it is downloaded
+ * bbn.fn.download('/files/f4b1092d71aefd96458feaa71d170f69.pdf', 'myDocument_' + bbn.fn.dateSQL() + '.pdf');
+ * ```
+ *
+ * @param    {String} url      The URL from which the file will be requested
+ * @param    {String} filename The name for the downloaded file (otherwise it will take the basename of the url)
+ * @param    {Object} params   A data object to send with the request
+ *
+ * @returns  {undefined}
+ */
+const download = function (url, filename, params) {
+    // We can intervert the arguments
+    if (filename && (typeof (filename) === 'object')) {
+        params = filename;
+        filename = '';
+    }
+    return ajax(url, 'blob', params || { _bbn_download: 1 }, (d, headers) => {
+        if (!filename) {
+            let cd = 'attachment; filename=';
+            if (headers?.['content-disposition'] && headers['content-disposition'].indexOf(cd) === 0) {
+                filename = substr(headers['content-disposition'], cd.length + 1, headers['content-disposition'].length - cd.length - 2);
+            }
+            else {
+                filename = baseName(url);
+            }
+        }
+        if (isBlob(d)) {
+            let extension = fileExt(filename);
+            let htmlExtensions = ['php', 'html'];
+            if ((typeof filename === 'string') && ((('type' in d) && (d.type !== 'text/html')) || htmlExtensions.includes(extension))) {
+                downloadContent(filename, d);
+                return;
+            }
+        }
+    }, e => {
+        defaultAjaxErrorFunction(e);
+    });
+};
+export { download };

package/dist/fn/ajax/downloadContent.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Downloads a file with given filename from the given content.
+ *
+ * Creates a link putting in href a URL Object Blob made of the given content,
+ * which can be a canvas, a file or a blob object, or just a string.
+ *
+ * @method   downloadContent
+ * @global
+ * @memberof bbn.fn
+ *
+ * @example
+ * ```javascript
+ * // Download from a string
+ * bbn.fn.downloadContent('myTextFile.txt', 'Just a string\nThat we can save directly in a file', 'text/plain');
+ *
+ * // Download from a file
+ * let file = new File(["foo"], "foo.txt", {type: "text/plain"});
+ * bbn.fn.downloadContent('foo.txt', file);
+ * ```
+ *
+ * @param    {String}                        filename The name for the downloaded file
+ * @param    {HTMLCanvasElement|File|String} content  A Canvas, a File object or a String
+ * @param    {String}                        type     The type of file to be made
+ *
+ * @returns  {undefined}
+ */
+declare const downloadContent: (filename: string, content: any, type?: string) => void;
+export { downloadContent };

package/dist/fn/ajax/downloadContent.js

@@ -0,0 +1,74 @@
+import { isCanvas } from '../type/isCanvas';
+import { isObject } from '../type/isObject';
+import { isString } from '../type/isString';
+import { log } from '../browser/log';
+/**
+ * Downloads a file with given filename from the given content.
+ *
+ * Creates a link putting in href a URL Object Blob made of the given content,
+ * which can be a canvas, a file or a blob object, or just a string.
+ *
+ * @method   downloadContent
+ * @global
+ * @memberof bbn.fn
+ *
+ * @example
+ * ```javascript
+ * // Download from a string
+ * bbn.fn.downloadContent('myTextFile.txt', 'Just a string\nThat we can save directly in a file', 'text/plain');
+ *
+ * // Download from a file
+ * let file = new File(["foo"], "foo.txt", {type: "text/plain"});
+ * bbn.fn.downloadContent('foo.txt', file);
+ * ```
+ *
+ * @param    {String}                        filename The name for the downloaded file
+ * @param    {HTMLCanvasElement|File|String} content  A Canvas, a File object or a String
+ * @param    {String}                        type     The type of file to be made
+ *
+ * @returns  {undefined}
+ */
+const downloadContent = function (filename, content, type) {
+    if (isCanvas(content)) {
+        content.toBlob((blob) => {
+            // blob ready, download it
+            let a = document.createElement('a');
+            a.download = filename;
+            a.href = window.URL.createObjectURL(blob);
+            a.className = 'bbn-no';
+            a.click();
+            // delete the internal blob reference, to let the browser clear memory from it
+            window.URL.revokeObjectURL(a.href);
+        }, type || 'image/png');
+        return;
+    }
+    if (!type) {
+        type = isObject(content) && content.type ? content.type : 'octet/stream';
+    }
+    else if (type.indexOf('/') === -1) {
+        type = 'text/' + type;
+    }
+    let a = window.document.createElement('a');
+    a.className = 'bbn-no';
+    let src = null;
+    if (isString(content)) {
+        src = new Blob([content], { type: type });
+    }
+    else {
+        try {
+            src = content;
+        }
+        catch (e) {
+            log(e);
+        }
+    }
+    a.href = window.URL.createObjectURL(src);
+    a.download = filename;
+    // Append anchor to body.
+    document.body.appendChild(a);
+    a.click();
+    window.URL.revokeObjectURL(a.href);
+    // Remove anchor from body
+    document.body.removeChild(a);
+};
+export { downloadContent };

package/dist/fn/ajax/getLoader.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Finds the loader object corresponding to the given unique ID and returns it if found.
+ *
+ * The loader is an object representing an Ajax request, with the following properties:
+ * * _key_ is the unique ID (_requestId_) of the loader
+ * * _url_ is the URL called by the request
+ * * _loader_ is the Promise from the Axios XHR
+ * * _source_ is the source object for aborting the request
+ * * _start_ is the timestamp of the moment the request was sent
+ *
+ * @method   getLoader
+ * @global
+ * @memberof bbn.fn
+ *
+ * @example
+ * ```javascript
+ * bbn.fn.post('my/script', {a: 1, b: 2});
+ * let requestId = bbn.fn.getRequestId('my/script', {a: 1, b: 2});
+ * if (requestId) {
+ *   let loader = bbn.fn.getLoader(requestId);
+ *   console.log(loader);
+ *   // {
+ *   //    key: "my/script:af27f0e81533ae2bae3c25dea67359f6",
+ *   //    url: "my/script",
+ *   //    loader: {Promise},
+ *   //    source: {token: {CancelToken}, cancel: {Function}},
+ *   //    start: 1591804716757
+ *   // }
+ * }
+ * ```
+ *
+ * @param    {String} requestId The unique ID of the request as used in bbn.env.loaders
+ *
+ * @returns  {false|Object} The corresponding loader Object if it exists, false otherwise
+ */
+declare const getLoader: (requestId: string) => BbnLoader | null;
+export { getLoader };

package/dist/fn/ajax/getLoader.js

@@ -0,0 +1,44 @@
+import { search } from '../object/search';
+/**
+ * Finds the loader object corresponding to the given unique ID and returns it if found.
+ *
+ * The loader is an object representing an Ajax request, with the following properties:
+ * * _key_ is the unique ID (_requestId_) of the loader
+ * * _url_ is the URL called by the request
+ * * _loader_ is the Promise from the Axios XHR
+ * * _source_ is the source object for aborting the request
+ * * _start_ is the timestamp of the moment the request was sent
+ *
+ * @method   getLoader
+ * @global
+ * @memberof bbn.fn
+ *
+ * @example
+ * ```javascript
+ * bbn.fn.post('my/script', {a: 1, b: 2});
+ * let requestId = bbn.fn.getRequestId('my/script', {a: 1, b: 2});
+ * if (requestId) {
+ *   let loader = bbn.fn.getLoader(requestId);
+ *   console.log(loader);
+ *   // {
+ *   //    key: "my/script:af27f0e81533ae2bae3c25dea67359f6",
+ *   //    url: "my/script",
+ *   //    loader: {Promise},
+ *   //    source: {token: {CancelToken}, cancel: {Function}},
+ *   //    start: 1591804716757
+ *   // }
+ * }
+ * ```
+ *
+ * @param    {String} requestId The unique ID of the request as used in bbn.env.loaders
+ *
+ * @returns  {false|Object} The corresponding loader Object if it exists, false otherwise
+ */
+const getLoader = function (requestId) {
+    let idx = search(bbn.env.loaders, { key: requestId });
+    if (idx > -1) {
+        return bbn.env.loaders[idx];
+    }
+    return null;
+};
+export { getLoader };

package/dist/fn/ajax/getRequestId.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Returns a unique ID for a "loader" based on the URL, the data keys and the datatype.
+ *
+ * The routing functions don't allow to send the same request at the same moment,
+ * therefore a unique ID is generated to identify them, based on the URL,
+ * the keys of the data sent, and the expected returned data type.
+ *
+ * @method   getRequestId
+ * @global
+ *
+ * @example
+ * ```javascript
+ * // The URL is the first part of the key
+ * bbn.fn.getRequestId('my/location', {a: 1, b: 2});
+ * // my/location:af27f0e81533ae2bae3c25dea67359f6
+ * bbn.fn.getRequestId('my/other/location', {a: 1, b: 2});
+ * // my/other/location:af27f0e81533ae2bae3c25dea67359f6
+ * ```
+ *
+ * @example
+ * ```javascript
+ * // A change of value will not change the requestId
+ * bbn.fn.getRequestId('my/location', {a: 1, b: 3});
+ * // my/location:af27f0e81533ae2bae3c25dea67359f6
+ * // A change of key will
+ * bbn.fn.getRequestId('my/location', {a: 1, c: 3});
+ * // my/location:fde97ca7c6c998c911f4ab481a136d5f
+ * ```
+ *
+ * @example
+ * ```javascript
+ * // Same with nested object
+ * bbn.fn.getRequestId('my/location', {data: {a: 1, b: 3}});
+ * // my/location:a7a58435275054106c4e4c9fb0cea5e5
+ * bbn.fn.getRequestId('my/location', {data: {a: 1, b: 2}});
+ * // my/location:a7a58435275054106c4e4c9fb0cea5e5
+ * bbn.fn.getRequestId('my/location', {data: {a: 1, c: 3}});
+ * // my/location:730da481e30d421afbadf1f1282dabb7
+ * ```
+ *
+ * @memberof bbn.fn
+ *
+ * @param    {String} url      The URL used by the request
+ * @param    {Object} data     The data sent to the URL
+ * @param    {String} datatype The type of data requested (JSON by default)
+ *
+ * @returns  {String} The unique ID
+ */
+declare const getRequestId: (url: any, data: any, datatype: any) => string;
+export { getRequestId };

package/dist/fn/ajax/getRequestId.js

@@ -0,0 +1,62 @@
+import { iterate } from '../loop/iterate';
+import { md5 } from '../string/md5';
+/**
+ * Returns a unique ID for a "loader" based on the URL, the data keys and the datatype.
+ *
+ * The routing functions don't allow to send the same request at the same moment,
+ * therefore a unique ID is generated to identify them, based on the URL,
+ * the keys of the data sent, and the expected returned data type.
+ *
+ * @method   getRequestId
+ * @global
+ *
+ * @example
+ * ```javascript
+ * // The URL is the first part of the key
+ * bbn.fn.getRequestId('my/location', {a: 1, b: 2});
+ * // my/location:af27f0e81533ae2bae3c25dea67359f6
+ * bbn.fn.getRequestId('my/other/location', {a: 1, b: 2});
+ * // my/other/location:af27f0e81533ae2bae3c25dea67359f6
+ * ```
+ *
+ * @example
+ * ```javascript
+ * // A change of value will not change the requestId
+ * bbn.fn.getRequestId('my/location', {a: 1, b: 3});
+ * // my/location:af27f0e81533ae2bae3c25dea67359f6
+ * // A change of key will
+ * bbn.fn.getRequestId('my/location', {a: 1, c: 3});
+ * // my/location:fde97ca7c6c998c911f4ab481a136d5f
+ * ```
+ *
+ * @example
+ * ```javascript
+ * // Same with nested object
+ * bbn.fn.getRequestId('my/location', {data: {a: 1, b: 3}});
+ * // my/location:a7a58435275054106c4e4c9fb0cea5e5
+ * bbn.fn.getRequestId('my/location', {data: {a: 1, b: 2}});
+ * // my/location:a7a58435275054106c4e4c9fb0cea5e5
+ * bbn.fn.getRequestId('my/location', {data: {a: 1, c: 3}});
+ * // my/location:730da481e30d421afbadf1f1282dabb7
+ * ```
+ *
+ * @memberof bbn.fn
+ *
+ * @param    {String} url      The URL used by the request
+ * @param    {Object} data     The data sent to the URL
+ * @param    {String} datatype The type of data requested (JSON by default)
+ *
+ * @returns  {String} The unique ID
+ */
+const getRequestId = function (url, data, datatype) {
+    let d = {};
+    if (data) {
+        iterate(data, (a, n) => {
+            if (n.indexOf('_bbn') === -1) {
+                d[n] = a;
+            }
+        });
+    }
+    return url + ':' + md5((datatype || 'json') + JSON.stringify(d));
+};
+export { getRequestId };

package/dist/fn/ajax/link.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Follows a link and if needed by sending the corresponding Ajax request and executing bbn.fn.defaultPreLinkFunction.
+ *
+ * Once bbn has been initiated this function will be triggered every time a link is clicked.
+ * It accepts the same arguments as seen in treatAjaxArguments but will tipically just be called with a URL,
+ * the defaultLinkURL functions being in charge of loading the content
+ *
+ * @method   link
+ * @todo     Manage anchors + returned data unclear
+ * @global
+ * @memberof bbn.fn
+ *
+ * @example
+ * ```javascript
+ * // Will open in a new window/tab
+ * bbn.fn.link('https://nytimes.com');
+ * // Will send an Ajax request
+ * bbn.fn.link('my/page');
+ * // Will open your default email program
+ * bbn.fn.link('mailto:postmaster@test.com');
+ * ```
+ *
+ * @returns
+ */
+declare const link: (...args: any[]) => any;
+export { link };

package/dist/fn/ajax/link.js

@@ -0,0 +1,129 @@
+import { treatAjaxArguments } from './treatAjaxArguments';
+import { getLoader } from './getLoader';
+import { defaultPreLinkFunction } from '../default/defaultPreLinkFunction';
+import { ajax } from './ajax';
+import { log } from '../browser/log';
+import { isObject } from '../type/isObject';
+import { callback } from './callback';
+import { setNavigationVars } from './setNavigationVars';
+/**
+ * Follows a link and if needed by sending the corresponding Ajax request and executing bbn.fn.defaultPreLinkFunction.
+ *
+ * Once bbn has been initiated this function will be triggered every time a link is clicked.
+ * It accepts the same arguments as seen in treatAjaxArguments but will tipically just be called with a URL,
+ * the defaultLinkURL functions being in charge of loading the content
+ *
+ * @method   link
+ * @todo     Manage anchors + returned data unclear
+ * @global
+ * @memberof bbn.fn
+ *
+ * @example
+ * ```javascript
+ * // Will open in a new window/tab
+ * bbn.fn.link('https://nytimes.com');
+ * // Will send an Ajax request
+ * bbn.fn.link('my/page');
+ * // Will open your default email program
+ * bbn.fn.link('mailto:postmaster@test.com');
+ * ```
+ *
+ * @returns
+ */
+const link = function (...args) {
+    let cfg = treatAjaxArguments(args);
+    let ok = true;
+    /* If we can't find a correct link we load the current URL */
+    if (!cfg) {
+        return link(window.location.href);
+    }
+    /* Just executing the javascript if there is */
+    if (cfg.url.indexOf('javascript:') === 0) {
+        return true;
+    }
+    if (cfg.url.indexOf('data:') === 0) {
+        return true;
+    }
+    if (cfg.url.indexOf('#') === 0) {
+        location.href = bbn.env.url + cfg.url;
+        /*
+        if ( window.history ){
+          bbn.env.historyDisabled = true;
+          let state = h.state;
+          window.history.replaceState(null, state.title, bbn.env.url);
+        }
+        bbn.env.historyDisabled = false;
+        */
+        return true;
+    }
+    else if (cfg.url.indexOf('mailto:') === 0) {
+        /* Mail link */
+        bbn.env.ignoreUnload = true;
+        window.location.href = cfg.url;
+        setTimeout(() => {
+            bbn.env.ignoreUnload = false;
+        }, 0);
+        return false;
+    }
+    if (getLoader(cfg.url)) {
+        return false;
+    }
+    /* Opens an external page in a new window */
+    if ((cfg.url.indexOf('http://') === 0 || cfg.url.indexOf('https://') === 0) &&
+        cfg.url.indexOf(bbn.env.host) !== 0) {
+        if (cfg.e) {
+            cfg.e.preventDefault();
+        }
+        window.open(cfg.url);
+        return false;
+    }
+    else if (cfg.url !== bbn.env.params.join('/') || cfg.force) {
+        /* The URL is fine so go ahead if something is not already loading */
+        /* If a second callback is defined, it is triggered instead of defaultPreLinkFunction */
+        if (cfg.successFn) {
+            ok = cfg.successFn(cfg.url);
+        }
+        else if (defaultPreLinkFunction) {
+            ok = defaultPreLinkFunction(cfg.url, cfg.force, cfg.ele);
+            /*
+            if (ok.data !== undefined) {
+                extend(cfg.obj, ok.data);
+                ok = 1;
+            }
+            */
+        }
+        if (ok) {
+            if (ok !== 1 && typeof ok === 'string') {
+                cfg.url = ok;
+            }
+            /** todo Do we keep obj in the unique string or do we make that only one concurrent connection to the same address can occur at the same time? */
+            let errSt = bbn._('The Ajax call to') + ' ' + cfg.url + ' ';
+            return ajax(cfg.url, cfg.datatype, cfg.obj, function (res) {
+                if (!res) {
+                    log(errSt + bbn._('returned no answer'));
+                }
+                if (isObject(res)) {
+                    // If there's nothing in the result, just an empty object, the callback stops here and the URL is not changed
+                    if (Object.keys(res).length === 0) {
+                        log(errSt + bbn._('returned an empty object'));
+                    }
+                    if (res.new_url) {
+                        res.old_path = cfg.url;
+                        cfg.url = res.new_url;
+                    }
+                    else if (res.url && cfg.url !== res.url) {
+                        res.old_path = cfg.url;
+                    }
+                }
+                if (callback(cfg.url, res, cfg.successFn, null, cfg.ele) && res.noNav === undefined) {
+                    // This solution is not very clean (we can't shorten a URL)
+                    if (bbn.env.path.indexOf(cfg.url) !== 0) {
+                        setNavigationVars(cfg.url, (res.title ? res.title + ' - ' : '') + bbn.env.siteTitle);
+                    }
+                }
+            }, cfg.errorFn || null);
+        }
+    }
+    return true;
+};
+export { link };

package/dist/fn/ajax/post.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Creates a POST XHR through bbn.fn.ajax then launches bbn.fn.callback with the result.
+ *
+ * URL is the only mandatory argument (see treatAjaxArguments for the arguments).
+ *
+ * @method   post
+ * @global
+ * @memberof bbn.fn
+ *
+ * @example
+ * ```javascript
+ * bbn.fn.post('logout').then(() => {
+ *   document.location.reload();
+ * });
+ * // With data
+ * bbn.fn.post('login', {user: 'tn', pass: 'xxx'}).then((d) => {
+ *  if (d && d.success) {
+ *    alert('Welcome!');
+ *  }
+ * });
+ * // With the callback as argument
+ * bbn.fn.post('login', {user: 'tn', pass: 'xxx'}, (d) => {
+ *  if (d && d.success) {
+ *    alert('Welcome!');
+ *  }
+ * }, (err) => {
+ *   bbn.fn.log(err);
+ *   mySpecialErrorFunction(err);
+ * });
+ * ```
+ *
+ * @returns  {undefined|Promise}
+ */
+declare const post: (...args: any[]) => any;
+export { post };

package/dist/fn/ajax/post.js

@@ -0,0 +1,45 @@
+import { treatAjaxArguments } from './treatAjaxArguments';
+import { ajax } from './ajax';
+import { callback } from './callback';
+/**
+ * Creates a POST XHR through bbn.fn.ajax then launches bbn.fn.callback with the result.
+ *
+ * URL is the only mandatory argument (see treatAjaxArguments for the arguments).
+ *
+ * @method   post
+ * @global
+ * @memberof bbn.fn
+ *
+ * @example
+ * ```javascript
+ * bbn.fn.post('logout').then(() => {
+ *   document.location.reload();
+ * });
+ * // With data
+ * bbn.fn.post('login', {user: 'tn', pass: 'xxx'}).then((d) => {
+ *  if (d && d.success) {
+ *    alert('Welcome!');
+ *  }
+ * });
+ * // With the callback as argument
+ * bbn.fn.post('login', {user: 'tn', pass: 'xxx'}, (d) => {
+ *  if (d && d.success) {
+ *    alert('Welcome!');
+ *  }
+ * }, (err) => {
+ *   bbn.fn.log(err);
+ *   mySpecialErrorFunction(err);
+ * });
+ * ```
+ *
+ * @returns  {undefined|Promise}
+ */
+const post = function (...args) {
+    let cfg = treatAjaxArguments(args);
+    if (cfg.url) {
+        return ajax(cfg.url, cfg.datatype, cfg.obj, (res) => {
+            callback(cfg.url, res, cfg.successFn, null, cfg.ele);
+        }, cfg.errorFn, cfg.abortFn);
+    }
+};
+export { post };

package/dist/fn/ajax/postOut.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Posts a request in a new window.
+ *
+ * @method   postOut
+ * @global
+ * @memberof bbn.fn
+ *
+ * @example
+ * ```javascript
+ * bbn.fn.postOut('https://external-service.com/download/account-2019-06.pdf', {clientId: 547912, token: xxx});
+ * ```
+ *
+ * @param    {String}   url     The url to which the request should be sent
+ * @param    {Object}   data    The data to be sent
+ * @param    {Function} success A function to execute in case of success
+ * @param    {String}   target  The target attribute of the form
+ *
+ * @returns  {undefined}
+ */
+declare const postOut: (url: string, data: BbnBasicObject, success?: () => any, target?: string) => void;
+export { postOut };

package/dist/fn/ajax/postOut.js

@@ -0,0 +1,49 @@
+import { createObject } from '../object/createObject';
+import { addInputs } from '../form/addInputs';
+/**
+ * Posts a request in a new window.
+ *
+ * @method   postOut
+ * @global
+ * @memberof bbn.fn
+ *
+ * @example
+ * ```javascript
+ * bbn.fn.postOut('https://external-service.com/download/account-2019-06.pdf', {clientId: 547912, token: xxx});
+ * ```
+ *
+ * @param    {String}   url     The url to which the request should be sent
+ * @param    {Object}   data    The data to be sent
+ * @param    {Function} success A function to execute in case of success
+ * @param    {String}   target  The target attribute of the form
+ *
+ * @returns  {undefined}
+ */
+const postOut = function (url, data, success, target) {
+    let form = document.body.querySelector('form#bbn-form_out');
+    if (!form) {
+        form = document.createElement('form');
+        form.classList.add('bbn-no');
+        form.setAttribute('id', 'bbn-form_out');
+        form.setAttribute('method', 'post');
+        form.setAttribute('enctype', 'multipart/form-data-encoded');
+        form.style.display = 'none';
+        document.body.appendChild(form);
+    }
+    form.innerHTML = '';
+    form.setAttribute('action', url);
+    form.setAttribute('target', target || '_blank');
+    if (!data) {
+        data = {};
+    }
+    data = createObject(data);
+    if (!data.bbn) {
+        data.bbn = 'public';
+    }
+    addInputs(form, data);
+    form.submit();
+    if (success) {
+        success();
+    }
+};
+export { postOut };