@datalayer/core 0.0.1 → 0.0.2

package/lib/utils/Array.d.ts

@@ -0,0 +1,2 @@
+export declare const asArray: (obj: any) => any[];
+export declare const shuffleArray: (array: Array<any>) => void;

package/lib/utils/Array.js

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/*
+ * Copyright (c) 2021-2024 Datalayer, Inc.
+ *
+ * Datalayer License
+ */
+export const asArray = (obj) => {
+    if (Array.isArray(obj)) {
+        return obj;
+    }
+    return [obj];
+};
+export const shuffleArray = (array) => {
+    for (let i = array.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [array[i], array[j]] = [array[j], array[i]];
+    }
+};

package/lib/utils/Avatar.d.ts

@@ -0,0 +1,9 @@
+export declare const DEFAULT_AVATAR_URL = "https://avatars.githubusercontent.com/u/70511875?s=200&v=4";
+export declare const DEFAULT_AVATAR_URL_ENCODED: string;
+export declare function stringAvatar(name: string): {
+    sx: {
+        bgcolor: string;
+    };
+    children: string;
+};
+export declare function getAvatarURL(url?: string): string;

package/lib/utils/Avatar.js

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/*
+ * Copyright (c) 2021-2024 Datalayer, Inc.
+ *
+ * Datalayer License
+ */
+export const DEFAULT_AVATAR_URL = 'https://avatars.githubusercontent.com/u/70511875?s=200&v=4';
+export const DEFAULT_AVATAR_URL_ENCODED = encodeURIComponent(DEFAULT_AVATAR_URL);
+function stringToColor(string) {
+    let hash = 0;
+    let i;
+    for (i = 0; i < string.length; i += 1) {
+        hash = string.charCodeAt(i) + ((hash << 5) - hash);
+    }
+    let color = '#';
+    for (i = 0; i < 3; i += 1) {
+        const value = (hash >> (i * 8)) & 0xff;
+        color += `00${value.toString(16)}`.substr(-2);
+    }
+    return color;
+}
+export function stringAvatar(name) {
+    return {
+        sx: {
+            bgcolor: stringToColor(name),
+        },
+        children: `${name.split(' ')[0][0]}${name.split(' ')[1][0]}`,
+    };
+}
+export function getAvatarURL(url) {
+    return url ?
+        url.startsWith('https://www.gravatar.com/avatar')
+            ? `${url}?v=4&s=200&d=${DEFAULT_AVATAR_URL_ENCODED}` // Use gravatar syntax - sizing works for Gravatar and GitHub
+            : url
+        : DEFAULT_AVATAR_URL; // This fallback should barely be used - hence we allow decoding the URI.
+}

package/lib/utils/Browser.d.ts

@@ -0,0 +1,3 @@
+export declare const detectBrowser: () => any;
+export declare function getBrowserType(): "Opera" | "Microsoft Edge" | "Google Chrome" | "Mozilla Firefox" | "Apple Safari" | "Microsoft Internet Explorer" | "UC Browser" | "Samsung Browser" | "Unknown browser";
+export default detectBrowser;

package/lib/utils/Browser.js

@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/*
+ * Copyright (c) 2021-2024 Datalayer, Inc.
+ *
+ * Datalayer License
+ */
+// https://stackoverflow.com/questions/49328382/browser-detection-in-reactjs
+// https://codepedia.info/detect-browser-in-javascript
+export const detectBrowser = () => {
+    const userAgent = navigator.userAgent;
+    let browserName;
+    if (userAgent.match(/chrome|chromium|crios/i)) {
+        browserName = "chrome";
+    }
+    else if (userAgent.match(/firefox|fxios/i)) {
+        browserName = "firefox";
+    }
+    else if (userAgent.match(/safari/i)) {
+        browserName = "safari";
+    }
+    else if (userAgent.match(/opr\//i)) {
+        browserName = "opera";
+    }
+    else if (userAgent.match(/edg/i)) {
+        browserName = "edge";
+    }
+    else {
+        browserName = "Unknow browser.";
+    }
+    return browserName;
+};
+// TODO Is this a duplicate of detectBrowser ?
+export function getBrowserType() {
+    const test = (regexp) => {
+        return regexp.test(navigator.userAgent);
+    };
+    if (test(/opr\//i)) {
+        return 'Opera';
+    }
+    else if (test(/edg/i)) {
+        return 'Microsoft Edge';
+    }
+    else if (test(/chrome|chromium|crios/i)) {
+        return 'Google Chrome';
+    }
+    else if (test(/firefox|fxios/i)) {
+        return 'Mozilla Firefox';
+    }
+    else if (test(/safari/i)) {
+        return 'Apple Safari';
+    }
+    else if (test(/trident/i)) {
+        return 'Microsoft Internet Explorer';
+    }
+    else if (test(/ucbrowser/i)) {
+        return 'UC Browser';
+    }
+    else if (test(/samsungbrowser/i)) {
+        return 'Samsung Browser';
+    }
+    else {
+        return 'Unknown browser';
+    }
+}
+export default detectBrowser;

package/lib/utils/Cells.d.ts

@@ -0,0 +1,2 @@
+import { IDataset } from "../models";
+export declare const getDatasetCell: (dataset: IDataset) => string;

package/lib/utils/Cells.js

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+export const getDatasetCell = (dataset) => {
+    switch (dataset.contentType) {
+        case 'application/vnd.ms-excel':
+        case 'text/csv':
+            return `# --- ✅ Load the ${dataset.fileName}.${dataset.datasetExtension} dataset (${dataset.mimeType})
+import pandas as pd
+${dataset.fileName}_${dataset.datasetExtension} = pd.read_csv("${dataset.cdnUrl}")
+${dataset.fileName}_${dataset.datasetExtension}
+
+`;
+        case 'image/png':
+        case 'image/jpg':
+        case 'image/jpeg':
+            return `# --- ✅ Display the ${dataset.fileName}.${dataset.datasetExtension} dataset (${dataset.mimeType})
+from IPython.display import Image
+url = "${dataset.cdnUrl}"
+Image(url, width=300)
+
+`;
+        default:
+            return `# --- 😞 File of type ${dataset.contentType} is not supported for now.
+`;
+    }
+};

package/lib/utils/Cookie.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Get a cookie from the document.
+ */
+export declare function getCookie(cname: string): string | undefined;
+/**
+ * Set a cookie in the document.
+ */
+export declare function setCookie(name: string, value: string, path?: string): void;
+/**
+ * Set a cookie in the document.
+ */
+export declare function deleteCookie(name: string): void;

package/lib/utils/Cookie.js

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/*
+ * Copyright (c) 2021-2024 Datalayer, Inc.
+ *
+ * Datalayer License
+ */
+/**
+ * Get a cookie from the document.
+ */
+export function getCookie(cname) {
+    // From http://www.tornadoweb.org/en/stable/guide/security.html
+    let cookie;
+    try {
+        cookie = document.cookie;
+    }
+    catch (e) {
+        // e.g. SecurityError in case of CSP Sandbox
+        return cookie;
+    }
+    // From https://www.w3schools.com/js/js_cookies.asp
+    const name = cname + "=";
+    const decodedCookie = decodeURIComponent(document.cookie);
+    const ca = decodedCookie.split(';');
+    for (let i = 0; i < ca.length; i++) {
+        let c = ca[i];
+        while (c.charAt(0) === ' ') {
+            c = c.substring(1);
+        }
+        if (c.indexOf(name) === 0) {
+            return c.substring(name.length, c.length);
+        }
+    }
+}
+/**
+ * Set a cookie in the document.
+ */
+export function setCookie(name, value, path = '/') {
+    //  document.cookie = "username=John Doe; expires=Thu, 18 Dec 2013 12:00:00 UTC; path=/";
+    const expire = new Date();
+    const time = expire.getTime();
+    const expireTime = time + 1000 * 36000;
+    expire.setTime(expireTime);
+    document.cookie = `${name}=${value}; expires=${expire.toUTCString()}; SameSite=Lax; path=${path}`;
+}
+/**
+ * Set a cookie in the document.
+ */
+export function deleteCookie(name) {
+    document.cookie = `${name}=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/;`;
+}

package/lib/utils/Date.d.ts

@@ -0,0 +1,2 @@
+export declare const getRelativeTime: (d1: Date, d2?: Date) => string;
+export declare const timeSince: (date: Date) => string;

package/lib/utils/Date.js

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/*
+ * Copyright (c) 2021-2024 Datalayer, Inc.
+ *
+ * Datalayer License
+ */
+//- Taken from https://stackoverflow.com/questions/6108819/javascript-timestamp-to-relative-time
+// in miliseconds
+const units = {
+    year: 24 * 60 * 60 * 1000 * 365,
+    month: (24 * 60 * 60 * 1000 * 365) / 12,
+    day: 24 * 60 * 60 * 1000,
+    hour: 60 * 60 * 1000,
+    minute: 60 * 1000,
+    second: 1000
+};
+const rtf = new Intl.RelativeTimeFormat(undefined, {
+    numeric: 'auto',
+    style: 'short'
+});
+export const getRelativeTime = (d1, d2 = new Date()) => {
+    var elapsed = d1.getTime() - d2.getTime();
+    // "Math.abs" accounts for both "past" & "future" scenarios
+    for (const u in units)
+        if (Math.abs(elapsed) > units[u] || u === 'second')
+            return rtf.format(Math.round(elapsed / units[u]), u);
+    return 'now';
+};
+//-
+const p = (i) => {
+    return i > 1 ? 's' : '';
+};
+export const timeSince = (date) => {
+    var seconds = Math.floor((new Date().getTime() - date.getTime()) / 1000);
+    var interval = seconds / 31536000;
+    if (interval > 1) {
+        const i = Math.floor(interval);
+        return i + ` year${p(i)}`;
+    }
+    interval = seconds / 2592000;
+    if (interval > 1) {
+        const i = Math.floor(interval);
+        return i + ` month${p(i)}`;
+    }
+    interval = seconds / 86400;
+    if (interval > 1) {
+        const i = Math.floor(interval);
+        return i + ` day${p(i)}`;
+    }
+    interval = seconds / 3600;
+    if (interval > 1) {
+        const i = Math.floor(interval);
+        return i + ` hour${p(i)}`;
+    }
+    interval = seconds / 60;
+    if (interval > 1) {
+        const i = Math.floor(interval);
+        return i + ` minute${p(i)}`;
+    }
+    const i = Math.floor(interval);
+    return i + ` second${p(i)}`;
+};

package/lib/utils/Download.d.ts

@@ -0,0 +1,3 @@
+export declare function jsonToCSVString(json: any): string;
+export declare const downloadJson: (data: any, fileName: string, extension: string) => void;
+export declare const downloadCSV: (data: any, fileName: string) => void;

package/lib/utils/Download.js

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/*
+ * Copyright (c) 2021-2024 Datalayer, Inc.
+ *
+ * Datalayer License
+ */
+export function jsonToCSVString(json) {
+    const headers = Object.keys(json[0]);
+    let csvString = '';
+    csvString += headers.join(',') + '\n';
+    json.forEach(obj => {
+        const rowCells = headers.map(header => {
+            const val = obj[header];
+            if (typeof val === "number") {
+                return val;
+            }
+            if (typeof val === "string") {
+                return val;
+            }
+            if (val instanceof Date) {
+                return val.toISOString();
+            }
+            return '';
+        });
+        const row = rowCells.join(',');
+        csvString += row + '\n';
+    });
+    return csvString;
+}
+export const downloadJson = (data, fileName, extension) => {
+    const jsonData = new Blob([JSON.stringify(data)], { type: 'application/json' });
+    const jsonURL = URL.createObjectURL(jsonData);
+    const jsonLink = document.createElement('a');
+    jsonLink.href = jsonURL;
+    jsonLink.download = `${fileName}.${extension}`;
+    document.body.appendChild(jsonLink);
+    jsonLink.click();
+    document.body.removeChild(jsonLink);
+};
+export const downloadCSV = (data, fileName) => {
+    const csvString = jsonToCSVString(data);
+    const csvData = new Blob([csvString], { type: 'text/csv' });
+    const csvURL = URL.createObjectURL(csvData);
+    const csvLink = document.createElement('a');
+    csvLink.href = csvURL;
+    csvLink.download = `${fileName}.csv`;
+    document.body.appendChild(csvLink);
+    csvLink.click();
+    document.body.removeChild(csvLink);
+};

package/lib/utils/DownloadFile.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @param data
+ * @param filename
+ * @param mime See https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types
+ * @param bom A byte order mark (BOM) is a sequence of bytes used to indicate Unicode encoding of a text file. The underlying character code, U+FEFF , takes one of the following forms depending on the character encoding.
+ *
+ * .zip	ZIP archive	application/zip
+ */
+export declare const downloadFile: (data: any, filename: string, mime?: any, bom?: any) => void;
+export default downloadFile;

package/lib/utils/DownloadFile.js

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/*
+ * Copyright (c) 2021-2024 Datalayer, Inc.
+ *
+ * Datalayer License
+ */
+/**
+ * @param data
+ * @param filename
+ * @param mime See https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types
+ * @param bom A byte order mark (BOM) is a sequence of bytes used to indicate Unicode encoding of a text file. The underlying character code, U+FEFF , takes one of the following forms depending on the character encoding.
+ *
+ * .zip	ZIP archive	application/zip
+ */
+export const downloadFile = (data, filename, mime, bom) => {
+    const blobData = (typeof bom !== 'undefined') ? [bom, data] : [data];
+    const blob = new Blob(blobData, { type: mime || 'application/octet-stream' });
+    const blobURL = (window.URL && window.URL.createObjectURL) ? window.URL.createObjectURL(blob) : window.webkitURL.createObjectURL(blob);
+    const tempLink = document.createElement('a');
+    tempLink.style.display = 'none';
+    tempLink.href = blobURL;
+    tempLink.setAttribute('download', filename);
+    // Safari thinks _blank anchor are pop ups. We only want to set _blank
+    // target if the browser does not support the HTML5 download attribute.
+    // This allows you to download files in desktop safari if pop up blocking
+    // is enabled.
+    if (typeof tempLink.download === 'undefined') {
+        tempLink.setAttribute('target', '_blank');
+    }
+    document.body.appendChild(tempLink);
+    tempLink.click();
+    // Fixes "webkit blob resource error 1"
+    setTimeout(function () {
+        document.body.removeChild(tempLink);
+        window.URL.revokeObjectURL(blobURL);
+    }, 200);
+};
+export default downloadFile;

package/lib/utils/Env.d.ts

@@ -0,0 +1 @@
+export declare const isDevDeployment: () => boolean;

package/lib/utils/Env.js

@@ -0,0 +1,12 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/*
+ * Copyright (c) 2021-2024 Datalayer, Inc.
+ *
+ * Datalayer License
+ */
+export const isDevDeployment = () => {
+    return location.hostname.startsWith('dev') || location.hostname.startsWith('localhost');
+};

package/lib/utils/File.d.ts

@@ -0,0 +1,7 @@
+/**
+ * creates name of file.
+ *
+ * @param {string} extension
+ * @param {string[]} parts of file name
+ */
+export declare const createFileName: (extension?: string, ...names: any[]) => string;

package/lib/utils/File.js

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/*
+ * Copyright (c) 2021-2024 Datalayer, Inc.
+ *
+ * Datalayer License
+ */
+/**
+ * creates name of file.
+ *
+ * @param {string} extension
+ * @param {string[]} parts of file name
+ */
+export const createFileName = (extension = '', ...names) => {
+    if (!extension) {
+        return '';
+    }
+    return `${names.join('')}.${extension}`;
+};

package/lib/utils/Format.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The type of unit used for reporting memory usage.
+ */
+export type MemoryUnit = 'B' | 'KB' | 'MB' | 'GB' | 'TB' | 'PB';
+/**
+ * The number of bytes in each memory unit.
+ */
+export declare const MEMORY_UNIT_LIMITS: {
+    readonly [U in MemoryUnit]: number;
+};
+export declare function formatForDisplay(numBytes: number | undefined, units?: MemoryUnit | undefined): string;
+/**
+ * Given a number of bytes, convert to the most human-readable
+ * format, (GB, TB, etc).
+ * If "units" is given, convert to that scale
+ */
+export declare function convertToLargestUnit(numBytes: number | undefined, units?: MemoryUnit): [number, MemoryUnit];

package/lib/utils/Format.js

@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * The number of bytes in each memory unit.
+ */
+export const MEMORY_UNIT_LIMITS = {
+    B: 1,
+    KB: 1024,
+    MB: 1048576,
+    GB: 1073741824,
+    TB: 1099511627776,
+    PB: 1125899906842624,
+};
+export function formatForDisplay(numBytes, units) {
+    const lu = convertToLargestUnit(numBytes, units);
+    return lu[0].toFixed(2) + ' ' + lu[1];
+}
+/**
+ * Given a number of bytes, convert to the most human-readable
+ * format, (GB, TB, etc).
+ * If "units" is given, convert to that scale
+ */
+export function convertToLargestUnit(numBytes, units) {
+    if (!numBytes) {
+        return [0, 'B'];
+    }
+    if (units && units in MEMORY_UNIT_LIMITS) {
+        return [numBytes / MEMORY_UNIT_LIMITS[units], units];
+    }
+    else if (numBytes < MEMORY_UNIT_LIMITS.KB) {
+        return [numBytes, 'B'];
+    }
+    else if (MEMORY_UNIT_LIMITS.KB === numBytes ||
+        numBytes < MEMORY_UNIT_LIMITS.MB) {
+        return [numBytes / MEMORY_UNIT_LIMITS.KB, 'KB'];
+    }
+    else if (MEMORY_UNIT_LIMITS.MB === numBytes ||
+        numBytes < MEMORY_UNIT_LIMITS.GB) {
+        return [numBytes / MEMORY_UNIT_LIMITS.MB, 'MB'];
+    }
+    else if (MEMORY_UNIT_LIMITS.GB === numBytes ||
+        numBytes < MEMORY_UNIT_LIMITS.TB) {
+        return [numBytes / MEMORY_UNIT_LIMITS.GB, 'GB'];
+    }
+    else if (MEMORY_UNIT_LIMITS.TB === numBytes ||
+        numBytes < MEMORY_UNIT_LIMITS.PB) {
+        return [numBytes / MEMORY_UNIT_LIMITS.TB, 'TB'];
+    }
+    else {
+        return [numBytes / MEMORY_UNIT_LIMITS.PB, 'PB'];
+    }
+}

package/lib/utils/Ids.d.ts

@@ -0,0 +1,2 @@
+export declare const newUuid: () => string;
+export declare const newUlid: () => string;

package/lib/utils/Ids.js

@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/*
+ * Copyright (c) 2021-2024 Datalayer, Inc.
+ *
+ * Datalayer License
+ */
+import { v4 as uuid_v4 } from 'uuid';
+import { ulid } from 'ulid';
+export const newUuid = () => {
+    return uuid_v4();
+};
+export const newUlid = () => {
+    return ulid();
+};

package/lib/utils/Jupyter.d.ts

@@ -0,0 +1 @@
+export declare function isInsideJupyterLab(): boolean;

package/lib/utils/Jupyter.js

@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/*
+ * Copyright (c) 2021-2024 Datalayer, Inc.
+ *
+ * Datalayer License
+ */
+import { PageConfig } from '@jupyterlab/coreutils';
+let _insideJupyterLab = null;
+export function isInsideJupyterLab() {
+    if (_insideJupyterLab === null) {
+        _insideJupyterLab = PageConfig.getOption('appName') === 'JupyterLab';
+    }
+    return _insideJupyterLab;
+}

package/lib/utils/Lazy.d.ts

@@ -0,0 +1,8 @@
+import { ComponentType } from "react";
+export type PreloadableComponent<T extends ComponentType<any>> = T & {
+    preload: () => Promise<void>;
+};
+export declare function lazyWithPreload<T extends ComponentType<any>>(factory: () => Promise<{
+    default: T;
+}>): PreloadableComponent<T>;
+export default lazyWithPreload;

package/lib/utils/Lazy.js

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/*
+ * Copyright (c) 2021-2024 Datalayer, Inc.
+ *
+ * Datalayer License
+ */
+// Taken from https://github.com/ianschmitz/react-lazy-with-preload with Datalayer License.
+import { createElement, forwardRef, lazy as reactLazy } from "react";
+export function lazyWithPreload(factory) {
+    const LazyComponent = reactLazy(factory);
+    let factoryPromise;
+    let LoadedComponent;
+    const Component = forwardRef(function LazyWithPreload(props, ref) {
+        return createElement(LoadedComponent ?? LazyComponent, Object.assign(ref ? { ref } : {}, props));
+    });
+    Component.preload = () => {
+        if (!factoryPromise) {
+            factoryPromise = factory().then((module) => {
+                LoadedComponent = module.default;
+            });
+        }
+        return factoryPromise;
+    };
+    return Component;
+}
+export default lazyWithPreload;

package/lib/utils/Msc.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Utility function to format strings
+ */
+export declare const formatString: (input: string) => string;
+/**
+ * Utility function to add numbers
+ */
+export declare const addNumbers: (a: number, b: number) => number;
+/**
+ * Utility function to check if a value is defined
+ */
+export declare const isDefined: <T>(value: T | undefined | null) => value is T;
+/**
+ * Utility function to delay execution
+ */
+export declare const delay: (ms: number) => Promise<void>;