@datalayer/core 0.0.1 → 0.0.3

package/lib/utils/File.js

@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD 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,12 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD 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,12 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD 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,23 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD 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>;

package/lib/utils/Msc.js

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Utility function to format strings
+ */
+export const formatString = (input) => {
+    return input.trim().toLowerCase();
+};
+/**
+ * Utility function to add numbers
+ */
+export const addNumbers = (a, b) => {
+    return a + b;
+};
+/**
+ * Utility function to check if a value is defined
+ */
+export const isDefined = (value) => {
+    return value !== undefined && value !== null;
+};
+/**
+ * Utility function to delay execution
+ */
+export const delay = (ms) => {
+    return new Promise(resolve => setTimeout(resolve, ms));
+};

package/lib/utils/Name.d.ts

@@ -0,0 +1,7 @@
+export declare const asDisplayName: (givenName: string, familyName: string) => string;
+export declare const nameAsInitials: (name: string) => string;
+export declare const namesAsInitials: (firstName: string, lastName: string) => string;
+/**
+ * Convert first and last names to a friendly name.
+ */
+export declare const toFriendlyName: (firstName?: string, lastName?: string) => string;

package/lib/utils/Name.js

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+export const asDisplayName = (givenName, familyName) => {
+    return givenName ?
+        familyName ?
+            (givenName + ' ' + familyName) : givenName
+        :
+            familyName ?? '';
+};
+export const nameAsInitials = (name) => {
+    return name
+        .replace(/\s+/, ' ')
+        .split(' ')
+        .slice(0, 2)
+        .map((v) => v && v[0].toUpperCase())
+        .join('');
+};
+export const namesAsInitials = (firstName, lastName) => {
+    return ((firstName || ' ').charAt(0) + (lastName || ' ').charAt(0)).toLocaleUpperCase().trim();
+};
+/**
+ * Convert first and last names to a friendly name.
+ */
+export const toFriendlyName = (firstName, lastName) => {
+    if (firstName) {
+        return firstName;
+    }
+    if (lastName) {
+        return lastName;
+    }
+    return "";
+};

package/lib/utils/Notebook.d.ts

@@ -0,0 +1,19 @@
+import { JupyterLab } from '@jupyterlab/application';
+/**
+ * Create a notebook
+ *
+ * @param app JupyterLab application
+ * @param name Notebook name
+ * @param url Notebook content URL
+ */
+export declare const createNotebook: ({ app, name, url, options }: {
+    app: JupyterLab;
+    name?: string;
+    url?: string;
+    options?: {
+        cwd?: string;
+        kernelId?: string;
+        kernelName?: string;
+    };
+}) => Promise<void>;
+export declare const createNotebookVariant: (app: JupyterLab, name: string, url: string) => Promise<void>;

package/lib/utils/Notebook.js

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Create a notebook
+ *
+ * @param app JupyterLab application
+ * @param name Notebook name
+ * @param url Notebook content URL
+ */
+export const createNotebook = async ({ app, name, url, options }) => {
+    const notebook = await app.commands.execute('notebook:create-new', options);
+    /*
+    if (name) {
+      notebook.context.rename(name + '.ipynb');
+    }
+    */
+    if (url) {
+        const nbmodel = await fetch(url);
+        const nbmodelText = await nbmodel.text();
+        const text = nbmodelText.replaceAll('\n', `
+`);
+        notebook.context.model.fromJSON({
+            ...JSON.parse(text)
+        });
+    }
+};
+export const createNotebookVariant = async (app, name, url) => {
+    const notebook = await app.commands.execute('notebook:create-new', { cwd: '/' });
+    notebook.context.rename(name + '.ipynb');
+    const nbmodel = await fetch(url);
+    const text = (await nbmodel.text()).replaceAll('\\n', '');
+    notebook.context.model.fromJSON({
+        ...JSON.parse(text)
+    });
+};

package/lib/utils/Number.d.ts

@@ -0,0 +1 @@
+export declare function numberFormatter(num: number, digits?: number): string;

package/lib/utils/Number.js

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+const LOOKUP_VALUE_SYMBOL = [
+    { value: 1, symbol: "" },
+    { value: 1e3, symbol: "K" },
+    { value: 1e6, symbol: "M" },
+    { value: 1e9, symbol: "G" },
+    { value: 1e12, symbol: "T" },
+    { value: 1e15, symbol: "P" },
+    { value: 1e18, symbol: "E" },
+];
+// https://stackoverflow.com/questions/9461621/format-a-number-as-2-5k-if-a-thousand-or-more-otherwise-900
+export function numberFormatter(num, digits = 1) {
+    const rx = /\.0+$|(\.[0-9]*[1-9])0+$/;
+    const item = LOOKUP_VALUE_SYMBOL.slice().reverse().find(function (item) {
+        return num >= item.value;
+    });
+    return item ? (num / item.value).toFixed(digits).replace(rx, "$1") + item.symbol : "0";
+}

package/lib/utils/Plots.d.ts

@@ -0,0 +1,16 @@
+import type { IUsage } from '../models';
+/**
+ * Compute the data for plotting the usage histogram.
+ *
+ * @param usages Usages
+ * @param interval Histogram interval
+ * @param range Range with month in 1-based scale
+ * @returns Histogram data {x: [], y: []}
+ */
+export declare function createHistogram(usages: IUsage[], interval: number, range: {
+    month: number;
+    year: number;
+}): {
+    x: string[];
+    y: number[];
+};

package/lib/utils/Plots.js

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { getDate, getDaysInMonth, getMonth, isSameMonth, isSameYear } from 'date-fns';
+/**
+ * Compute the data for plotting the usage histogram.
+ *
+ * @param usages Usages
+ * @param interval Histogram interval
+ * @param range Range with month in 1-based scale
+ * @returns Histogram data {x: [], y: []}
+ */
+export function createHistogram(usages, interval, range) {
+    const referenceDate = new Date(range.year, range.month - 1);
+    const now = Date.now();
+    const credits = usages
+        .filter(c => interval === 0
+        ? isSameMonth(c.startDate, referenceDate)
+        : isSameYear(c.startDate, referenceDate))
+        .map(c => {
+        const start = c.startDate;
+        const end = c.endDate?.getTime() ?? now;
+        return {
+            credits: typeof c.credits === 'number'
+                ? c.credits
+                : ((end - start.getTime()) * c.burningRate) / 1000,
+            // getDate is 1-based but getMonth is 0-based
+            category: interval === 0 ? getDate(start) - 1 : getMonth(start)
+        };
+    })
+        .reduce((agg, d) => {
+        agg[d.category] += d.credits;
+        return agg;
+    }, new Array(interval === 0 ? getDaysInMonth(referenceDate) : 12).fill(0))
+        .map(c => Math.round(c));
+    return {
+        x: interval === 0
+            ? credits.map((_, i) => `${i + 1}`)
+            : [
+                'Jan',
+                'Feb',
+                'Mar',
+                'Apr',
+                'May',
+                'Jun',
+                'Jul',
+                'Aug',
+                'Sep',
+                'Oct',
+                'Nov',
+                'Dec'
+            ],
+        y: credits
+    };
+}

package/lib/utils/Random.d.ts

@@ -0,0 +1 @@
+export declare function getRandomInt(max: number): number;

package/lib/utils/Random.js

@@ -0,0 +1,7 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+export function getRandomInt(max) {
+    return Math.floor(Math.random() * max);
+}

package/lib/utils/Screenshot.d.ts

@@ -0,0 +1 @@
+export declare const takeHTMLNodeScreenshot: (node: HTMLDivElement) => Promise<string>;

package/lib/utils/Screenshot.js

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import html2canvas from 'html2canvas';
+export const takeHTMLNodeScreenshot = async (node) => {
+    const sc = html2canvas(node, {
+        width: node.getBoundingClientRect().width,
+        height: node.getBoundingClientRect().height,
+    });
+    return sc.then((canvas) => {
+        const croppedCanvas = document.createElement('canvas');
+        const croppedCanvasContext = croppedCanvas.getContext('2d');
+        const top = 0;
+        const left = 0;
+        const width = canvas.width;
+        const height = canvas.height;
+        croppedCanvas.width = width;
+        croppedCanvas.height = height;
+        croppedCanvasContext?.drawImage(canvas, left, top, width, height, left, top, width, height);
+        //    const type = 'image/jpeg';
+        const type = 'image/png';
+        const quality = 1;
+        const outputshotData = croppedCanvas.toDataURL(type, quality);
+        return outputshotData;
+    });
+};

package/lib/utils/Scroll.d.ts

@@ -0,0 +1,2 @@
+declare const smoothScroll: (target: string) => void;
+export default smoothScroll;

package/lib/utils/Scroll.js

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+const easeInOutQuad = (t, b, c, d) => {
+    t /= d / 2;
+    if (t < 1)
+        return (c / 2) * t * t + b;
+    t--;
+    return (-c / 2) * (t * (t - 2) - 1) + b;
+};
+const scrollGo = (element, target, to, duration) => {
+    const start = element.scrollTop, change = to - start, increment = 20;
+    let currentTime = 0;
+    const animateScroll = () => {
+        currentTime += increment;
+        const scrollTop = easeInOutQuad(currentTime, start, change, duration);
+        element.scrollTop = scrollTop;
+        if (currentTime < duration) {
+            setTimeout(animateScroll, increment);
+        }
+        else {
+            window.location.hash = target;
+        }
+    };
+    animateScroll();
+};
+const smoothScroll = (target) => {
+    const targetScroll = document.getElementById(target);
+    scrollGo(document.body, target, targetScroll?.offsetTop, 1250);
+};
+export default smoothScroll;

package/lib/utils/Sleep.d.ts

@@ -0,0 +1,2 @@
+export declare const sleep: (ms: number) => Promise<unknown>;
+export default sleep;

package/lib/utils/Sleep.js

@@ -0,0 +1,8 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+export const sleep = async (ms) => {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+};
+export default sleep;

package/lib/utils/Snapshot.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Create an unique human readable kernel snapshot name.
+ *
+ * @param suffix Name prefix
+ * @returns The kernel snapshot name
+ */
+export declare function createRuntimeSnapshotName(suffix: string): string;

package/lib/utils/Snapshot.js

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { adjectives, animals, uniqueNamesGenerator } from 'unique-names-generator';
+/**
+ * Kernel snapshot description configuration.
+ */
+const KERNEL_SNAPSHOT_DESCRIPTION_CONFIGURATION = {
+    dictionaries: [adjectives, animals],
+    separator: '-'
+};
+/**
+ * Create an unique human readable kernel snapshot name.
+ *
+ * @param suffix Name prefix
+ * @returns The kernel snapshot name
+ */
+export function createRuntimeSnapshotName(suffix) {
+    return `${uniqueNamesGenerator(KERNEL_SNAPSHOT_DESCRIPTION_CONFIGURATION)}-${suffix}`;
+}

package/lib/utils/String.d.ts

@@ -0,0 +1 @@
+export declare const strip: (s: string | undefined, max?: number) => string;

package/lib/utils/String.js

@@ -0,0 +1,13 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+export const strip = (s, max = 50) => {
+    if (!s) {
+        return "";
+    }
+    if (s.length > max) {
+        return s.substring(0, max) + "…";
+    }
+    return s;
+};

package/lib/utils/Uri.d.ts

@@ -0,0 +1,2 @@
+export declare const currentUri: () => string;
+export declare const dataURItoBlob: (dataURI: any) => Blob;

package/lib/utils/Uri.js

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+export const currentUri = () => {
+    return window.location.protocol + "//" + window.location.host;
+};
+// https://stackoverflow.com/questions/12168909/blob-from-dataurl
+export const dataURItoBlob = (dataURI) => {
+    // Convert base64 to raw binary data held in a string.
+    // Doesn't handle URLEncoded DataURIs - see SO answer #6850276 for code that does this.
+    const byteString = atob(dataURI.split(',')[1]);
+    // Separate out the mime component.
+    const mimeString = dataURI.split(',')[0].split(':')[1].split(';')[0];
+    // Write the bytes of the string to an ArrayBuffer.
+    const ab = new ArrayBuffer(byteString.length);
+    // Create a view into the buffer.
+    const ia = new Uint8Array(ab);
+    // Set the bytes of the buffer to the correct values.
+    for (let i = 0; i < byteString.length; i++) {
+        ia[i] = byteString.charCodeAt(i);
+    }
+    // Write the ArrayBuffer to a blob, and you're done.
+    const blob = new Blob([ab], { type: mimeString });
+    return blob;
+};

package/lib/utils/Validator.d.ts

@@ -0,0 +1,12 @@
+export declare const isValidEmail: (value?: string) => boolean;
+/**
+ * Verify if a string has a given length or not.
+ */
+export declare const validateLength: (value: string | undefined, minLength: number) => boolean;
+/**
+ * Check the password complexity
+ * @param password Password to validate
+ * @returns Whether the password various criteria
+ */
+export declare function isValidPassword(password: string): boolean;
+export declare function isValidUrl(url: string): boolean;

package/lib/utils/Validator.js

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+const EMAIL_REGEX = /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
+export const isValidEmail = (value) => {
+    if (!value) {
+        return false;
+    }
+    if (EMAIL_REGEX.test(value)) {
+        return true;
+    }
+    return false;
+};
+/**
+ * Verify if a string has a given length or not.
+ */
+export const validateLength = (value, minLength) => {
+    if (!value) {
+        return false;
+    }
+    if (value.length >= minLength) {
+        return true;
+    }
+    return false;
+};
+const PASSWORD_REGEX = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[[\]!"$%&/()=?@~`\\.';:+=^*#_-])[A-Za-z\d[\]!"$%&/()=?@~`\\.';:+=^*#_-]{8,64}$/;
+/**
+ * Check the password complexity
+ * @param password Password to validate
+ * @returns Whether the password various criteria
+ */
+export function isValidPassword(password) {
+    return PASSWORD_REGEX.test(password);
+}
+export function isValidUrl(url) {
+    try {
+        new URL(url);
+        return true;
+    }
+    catch (err) {
+        return false;
+    }
+}

package/lib/utils/WithSuspense.d.ts

@@ -0,0 +1,2 @@
+export declare const WithSuspense: (Component: any, preload?: boolean, skeleton?: boolean) => (props: any) => import("react/jsx-runtime").JSX.Element;
+export default WithSuspense;