@genome-spy/core 0.78.0 → 0.79.0

package/dist/src/data/sources/urlDescriptorState.js

@@ -0,0 +1,129 @@
+import {
+    loadUrlDescriptorOrSkip,
+    UrlLimitExceededError,
+    urlDescriptorKey,
+} from "./urlDescriptor.js";
+
+/**
+ * Tracks active URL descriptors, descriptor-keyed handles, and the descriptor
+ * set covered by the last published data batch.
+ *
+ * @template T
+ */
+export default class UrlDescriptorState {
+    /** @type {Map<string, T>} */
+    #handleCache = new Map();
+
+    /** @type {T[]} */
+    #handles = [];
+
+    /** @type {Set<string>} */
+    #activeKeys = new Set();
+
+    /** @type {Set<string>} */
+    #loadedKeys = new Set();
+
+    get handles() {
+        return this.#handles;
+    }
+
+    get activeSetLoaded() {
+        return this.#activeKeys.isSubsetOf(this.#loadedKeys);
+    }
+
+    markLoaded() {
+        this.#loadedKeys = new Set(this.#activeKeys);
+    }
+
+    clearActive() {
+        this.#handles = [];
+        this.#activeKeys = new Set();
+        this.#loadedKeys = new Set();
+    }
+
+    /**
+     * Refreshes active descriptors while reusing cached handles.
+     *
+     * @param {import("./urlDescriptor.js").UrlDescriptor[]} descriptors
+     * @param {(descriptor: import("./urlDescriptor.js").UrlDescriptor, descriptorKey: string) => Promise<T | undefined>} createHandle
+     */
+    async update(descriptors, createHandle) {
+        const descriptorKeys = descriptors.map(urlDescriptorKey);
+        const entries = await Promise.all(
+            descriptors.map((descriptor, i) =>
+                this.#getOrCreateHandle(
+                    descriptor,
+                    descriptorKeys[i],
+                    createHandle
+                )
+            )
+        );
+        this.#handles = entries
+            .filter((entry) => entry.handle)
+            .map((entry) => /** @type {T} */ (entry.handle));
+        this.#activeKeys = new Set(
+            entries
+                .filter((entry) => entry.handle)
+                .map((entry) => entry.descriptorKey)
+        );
+    }
+
+    /**
+     * @param {import("./urlDescriptor.js").UrlDescriptor} descriptor
+     * @param {string} descriptorKey
+     * @param {(descriptor: import("./urlDescriptor.js").UrlDescriptor, descriptorKey: string) => Promise<T | undefined>} createHandle
+     * @returns {Promise<{ descriptorKey: string, handle: T | undefined }>}
+     */
+    async #getOrCreateHandle(descriptor, descriptorKey, createHandle) {
+        const cachedHandle = this.#handleCache.get(descriptorKey);
+        if (cachedHandle) {
+            return { descriptorKey, handle: cachedHandle };
+        }
+
+        const handle = await createHandle(descriptor, descriptorKey);
+        if (handle) {
+            this.#handleCache.set(descriptorKey, handle);
+        }
+        return { descriptorKey, handle };
+    }
+}
+
+/**
+ * Updates descriptor-backed lazy-source handles using the shared multi-URL
+ * loading policy. Over-limit URL expansion is treated as an empty completed
+ * source so stale data is cleared without surfacing a runtime error.
+ *
+ * @template T
+ * @template M
+ * @param {{
+ *     controller: { normalize: () => Promise<import("./urlDescriptor.js").UrlDescriptor[]> },
+ *     state: UrlDescriptorState<T>,
+ *     clearData: () => void,
+ *     setLoadingStatus: (status: import("../../types/viewContext.js").DataLoadingStatus, detail?: string) => void,
+ *     loadModules: () => Promise<M>,
+ *     createHandle: (descriptor: import("./urlDescriptor.js").UrlDescriptor, modules: M) => Promise<T>,
+ * }} options
+ */
+export async function updateUrlDescriptorState(options) {
+    try {
+        const descriptors = await options.controller.normalize();
+        const modules = await options.loadModules();
+
+        options.setLoadingStatus("loading");
+        await options.state.update(descriptors, (descriptor) =>
+            loadUrlDescriptorOrSkip(descriptor, () =>
+                options.createHandle(descriptor, modules)
+            )
+        );
+        options.setLoadingStatus("complete");
+    } catch (e) {
+        options.clearData();
+        if (e instanceof UrlLimitExceededError) {
+            options.state.clearActive();
+            options.setLoadingStatus("complete");
+        } else {
+            options.setLoadingStatus("error", e.message);
+            throw e;
+        }
+    }
+}

package/dist/src/data/sources/urlSource.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"urlSource.d.ts","sourceRoot":"","sources":["../../../../src/data/sources/urlSource.js"],"names":[],"mappings":"AAuJA;;;GAGG;AACH,gCAHW,OAAO,CAAC,OAAO,oBAAoB,EAAE,IAAI,CAAC,GACxC,IAAI,IAAI,OAAO,oBAAoB,EAAE,OAAO,CAIxD;AA5ID;;;GAGG;AACH;IACI;;;OAGG;IACH,oBAHW,OAAO,oBAAoB,EAAE,OAAO,QACpC,OAAO,oBAAoB,EAAE,OAAO,EAc9C;IATG,6CAMC;IAED,gBAAiC;;CAgHxC;uBA9IsB,iBAAiB"}
+{"version":3,"file":"urlSource.d.ts","sourceRoot":"","sources":["../../../../src/data/sources/urlSource.js"],"names":[],"mappings":"AA+LA;;;GAGG;AACH,gCAHW,OAAO,CAAC,OAAO,oBAAoB,EAAE,IAAI,CAAC,GACxC,IAAI,IAAI,OAAO,oBAAoB,EAAE,OAAO,CAIxD;AA9KD;;;GAGG;AACH;IAII;;;OAGG;IACH,oBAHW,OAAO,oBAAoB,EAAE,OAAO,QACpC,OAAO,oBAAoB,EAAE,OAAO,EAkB9C;IAbG,6CAMC;IAED,gBAAiC;;CA+IxC;uBAtLsB,iBAAiB"}

package/dist/src/data/sources/urlSource.js

@@ -11,6 +11,12 @@ import {
     withoutExprRef,
 } from "../../paramRuntime/paramUtils.js";
 import { concatUrl } from "../../utils/url.js";
+import {
+    createDescriptorFieldAttacher,
+    loadUrlDescriptorOrSkip,
+    UrlLimitExceededError,
+} from "./urlDescriptor.js";
+import UrlDescriptorController from "./urlDescriptorController.js";
 
 const gzipMimeTypes = new Set(["application/gzip", "application/x-gzip"]);
 const textDecoder = new TextDecoder();
@@ -20,6 +26,9 @@ const textDecoder = new TextDecoder();
  * payloads before handing them to the registered format reader.
  */
 export default class UrlSource extends DataSource {
+    /** @type {UrlDescriptorController} */
+    #urlDescriptors;
+
     /**
      * @param {import("../../spec/data.js").UrlData} params
      * @param {import("../../view/view.js").default} view
@@ -36,6 +45,10 @@ export default class UrlSource extends DataSource {
         );
 
         this.baseUrl = view?.getBaseUrl();
+        this.#urlDescriptors = new UrlDescriptorController(this, {
+            getUrl: () => this.params.url,
+            onChange: () => this.load(),
+        });
     }
 
     get identifier() {
@@ -77,73 +90,100 @@ export default class UrlSource extends DataSource {
     }
 
     async load() {
-        const url = withoutExprRef(this.params.url);
-
-        /** @type {string[]} */
-        const urls =
-            typeof url == "object" && "urlsFromFile" in url
-                ? await this.#loadUrlsFromFile(url)
-                : (Array.isArray(url) ? url : [url]).map((u) =>
-                      concatUrl(this.baseUrl, u)
-                  );
-
-        const format = getFormat(this.params, urls);
-        const type = responseType(format.type);
-
-        if (urls.length === 0 || !urls[0]) {
-            this.reset();
-            this.complete();
-            return;
-        }
-
-        /** @param {string} url */
-        const load = async (url) => {
-            try {
-                const result = await fetch(url);
-                if (!result.ok) {
-                    throw new Error(`${result.status} ${result.statusText}`);
-                }
-                return await readResponseBody(result, url, type);
-            } catch (e) {
-                throw new Error(
-                    `Could not load data: ${url}. Reason: ${e.message}`,
-                    { cause: e }
-                );
-            }
-        };
-
-        /**
-         * @param {any} content
-         * @param {string} [url]
-         */
-        const readAndParse = async (content, url) => {
-            try {
-                /** @type {any[] | Promise<any[]>} */
-                const dataOrPromise = read(content, toVegaLoaderFormat(format));
-                const data =
-                    dataOrPromise instanceof Promise
-                        ? await dataOrPromise
-                        : dataOrPromise;
-                this.beginBatch({ type: "file", url: url });
-                for (const d of data) {
-                    this._propagate(d);
-                }
-            } catch (e) {
-                console.warn(e);
-                throw new Error(`Cannot parse: ${url}: ${e.message}`, {
-                    cause: e,
-                });
-            }
-        };
-
         this.setLoadingStatus("loading");
         this.reset();
 
         try {
-            await Promise.all(urls.map((url) => load(url).then(readAndParse)));
+            const url = withoutExprRef(this.params.url);
+
+            /** @type {import("./urlDescriptor.js").UrlDescriptor[]} */
+            const descriptors =
+                typeof url == "object" && "urlsFromFile" in url
+                    ? (await this.#loadUrlsFromFile(url)).map((url) => ({
+                          url,
+                      }))
+                    : await this.#urlDescriptors.normalize();
+
+            const urls = descriptors.map((descriptor) => descriptor.url);
+            if (urls.length > 0 && urls[0]) {
+                const format = getFormat(this.params, urls);
+                const type = responseType(format.type);
+
+                /** @param {string} url */
+                const load = async (url) => {
+                    try {
+                        const result = await fetch(url);
+                        if (!result.ok) {
+                            throw new Error(
+                                `${result.status} ${result.statusText}`
+                            );
+                        }
+                        return await readResponseBody(result, url, type);
+                    } catch (e) {
+                        throw new Error(
+                            `Could not load data: ${url}. Reason: ${e.message}`,
+                            { cause: e }
+                        );
+                    }
+                };
+
+                /**
+                 * @param {any} content
+                 * @param {import("./urlDescriptor.js").UrlDescriptor} descriptor
+                 */
+                const readAndParse = async (content, descriptor) => {
+                    try {
+                        /** @type {any[] | Promise<any[]>} */
+                        const dataOrPromise = read(
+                            content,
+                            toVegaLoaderFormat(format)
+                        );
+                        const data =
+                            dataOrPromise instanceof Promise
+                                ? await dataOrPromise
+                                : dataOrPromise;
+                        this.beginBatch({ type: "file", url: descriptor.url });
+                        const attachFields = createDescriptorFieldAttacher(
+                            descriptor.fields
+                        );
+                        for (const d of data) {
+                            this._propagate(attachFields(d));
+                        }
+                    } catch (e) {
+                        console.warn(e);
+                        throw new Error(
+                            `Cannot parse: ${descriptor.url}: ${e.message}`,
+                            {
+                                cause: e,
+                            }
+                        );
+                    }
+                };
+
+                const loaded = await Promise.all(
+                    descriptors.map((descriptor) =>
+                        loadUrlDescriptorOrSkip(descriptor, async () => ({
+                            descriptor,
+                            content: await load(descriptor.url),
+                        }))
+                    )
+                );
+
+                await Promise.all(
+                    loaded.map((entry) =>
+                        entry
+                            ? readAndParse(entry.content, entry.descriptor)
+                            : undefined
+                    )
+                );
+            }
             this.setLoadingStatus("complete");
         } catch (e) {
-            this.setLoadingStatus("error", e.message);
+            if (e instanceof UrlLimitExceededError) {
+                this.setLoadingStatus("complete");
+            } else {
+                this.setLoadingStatus("error", e.message);
+            }
         }
         this.complete();
     }

package/dist/src/data/transforms/packLegendLabels.d.ts

@@ -0,0 +1,21 @@
+export default class PackLegendLabelsTransform extends Transform {
+    /**
+     * @param {import("../../spec/transform.js").PackLegendLabelsParams} params
+     * @param {import("../flowNode.js").ParamRuntimeProvider} paramRuntimeProvider
+     */
+    constructor(params: import("../../spec/transform.js").PackLegendLabelsParams, paramRuntimeProvider: import("../flowNode.js").ParamRuntimeProvider);
+    params: import("../../spec/transform.js").PackLegendLabelsParams;
+    labelWidthAccessor: import("vega-util").AccessorFn<any>;
+    symbolSizeAccessor: import("vega-util").AccessorFn<any> | (() => string | number);
+    symbolStrokeWidthAccessor: import("vega-util").AccessorFn<any> | (() => string | number);
+    /** @type {number | undefined} */
+    yExtent: number | undefined;
+    /** @type {any[]} */
+    buffer: any[];
+    /**
+     * @param {any} datum
+     */
+    handle(datum: any): void;
+}
+import Transform from "./transform.js";
+//# sourceMappingURL=packLegendLabels.d.ts.map

package/dist/src/data/transforms/packLegendLabels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"packLegendLabels.d.ts","sourceRoot":"","sources":["../../../../src/data/transforms/packLegendLabels.js"],"names":[],"mappings":"AAgBA;IAKI;;;OAGG;IACH,oBAHW,OAAO,yBAAyB,EAAE,sBAAsB,wBACxD,OAAO,gBAAgB,EAAE,oBAAoB,EAsCvD;IAjCG,iEAAoB;IACpB,wDAAkD;IAClD,kFAGwC;IACxC,yFAG6C;IAC7C,iCAAiC;IACjC,SADW,MAAM,GAAG,SAAS,CACL;IAoBxB,oBAAoB;IACpB,QADW,GAAG,EAAE,CACA;IAQpB;;OAEG;IACH,cAFW,GAAG,QAIb;CAmHJ;sBA1LqB,gBAAgB"}

package/dist/src/data/transforms/packLegendLabels.js

@@ -0,0 +1,189 @@
+import { BEHAVIOR_MODIFIES } from "../flowNode.js";
+import { field } from "../../utils/field.js";
+import Transform from "./transform.js";
+import { isExprRef } from "../../paramRuntime/paramUtils.js";
+
+/**
+ * @param {unknown} symbolSize
+ * @param {unknown} symbolStrokeWidth
+ */
+function getSymbolExtent(symbolSize, symbolStrokeWidth) {
+    const size = Number(symbolSize);
+    const area = Number.isFinite(size) && size >= 0 ? size : 100;
+    const strokeWidth = Number(symbolStrokeWidth);
+    return Math.sqrt(area) + (Number.isFinite(strokeWidth) ? strokeWidth : 0);
+}
+
+export default class PackLegendLabelsTransform extends Transform {
+    get behavior() {
+        return BEHAVIOR_MODIFIES;
+    }
+
+    /**
+     * @param {import("../../spec/transform.js").PackLegendLabelsParams} params
+     * @param {import("../flowNode.js").ParamRuntimeProvider} paramRuntimeProvider
+     */
+    constructor(params, paramRuntimeProvider) {
+        super(params, paramRuntimeProvider);
+
+        this.params = params;
+        this.labelWidthAccessor = field(params.labelWidth);
+        this.symbolSizeAccessor =
+            typeof params.symbolSize == "string"
+                ? field(params.symbolSize)
+                : () => params.symbolSize ?? 100;
+        this.symbolStrokeWidthAccessor =
+            typeof params.symbolStrokeWidth == "string"
+                ? field(params.symbolStrokeWidth)
+                : () => params.symbolStrokeWidth ?? 0;
+        /** @type {number | undefined} */
+        this.yExtent = undefined;
+
+        if (isExprRef(params.yExtent)) {
+            const yExtentExpr = this.paramRuntime.watchExpression(
+                params.yExtent.expr,
+                () => {
+                    this.yExtent = yExtentExpr();
+                    this.repropagate();
+                },
+                {
+                    scopeOwned: false,
+                    registerDisposer: (disposer) =>
+                        this.registerDisposer(disposer),
+                }
+            );
+            this.yExtent = yExtentExpr();
+        } else {
+            this.yExtent = params.yExtent;
+        }
+
+        /** @type {any[]} */
+        this.buffer = [];
+    }
+
+    reset() {
+        super.reset();
+        this.buffer = [];
+    }
+
+    /**
+     * @param {any} datum
+     */
+    handle(datum) {
+        this.buffer.push(datum);
+    }
+
+    complete() {
+        const params = this.params;
+        const direction = params.direction ?? "vertical";
+        const rowPadding = params.rowPadding ?? 0;
+        const columnPadding = params.columnPadding ?? 0;
+        const labelOffset = params.labelOffset ?? 0;
+        const fontSize = params.fontSize ?? 10;
+        const xOffset = params.xOffset ?? 0;
+        const yOffset = params.yOffset ?? 0;
+        const symbolOffset = params.symbolOffset ?? 0;
+        const yExtent = this.yExtent;
+
+        /** @type {number} */
+        const n = this.buffer.length;
+        const columns =
+            params.columns && params.columns > 0
+                ? params.columns
+                : direction == "horizontal"
+                  ? n
+                  : 1;
+        const rows = Math.ceil(n / Math.max(columns, 1));
+
+        /** @type {number[]} */
+        const columnWidths = Array.from({ length: columns }, () => 0);
+        /** @type {number[]} */
+        const columnSymbolExtents = Array.from({ length: columns }, () => 0);
+        /** @type {number[]} */
+        const columnLabelWidths = Array.from({ length: columns }, () => 0);
+        /** @type {number[]} */
+        const rowHeights = Array.from({ length: rows }, () => 0);
+        /** @type {Array<{ row: number, column: number, symbolExtent: number }>} */
+        const entries = [];
+
+        for (let index = 0; index < n; index++) {
+            const datum = this.buffer[index];
+            const row =
+                direction == "horizontal"
+                    ? Math.floor(index / columns)
+                    : index % rows;
+            const column =
+                direction == "horizontal"
+                    ? index % columns
+                    : Math.floor(index / rows);
+            const symbolExtent = getSymbolExtent(
+                this.symbolSizeAccessor(datum),
+                this.symbolStrokeWidthAccessor(datum)
+            );
+            const labelWidth = this.labelWidthAccessor(datum);
+
+            entries.push({ row, column, symbolExtent });
+            columnSymbolExtents[column] = Math.max(
+                columnSymbolExtents[column],
+                symbolExtent
+            );
+            columnLabelWidths[column] = Math.max(
+                columnLabelWidths[column],
+                labelWidth
+            );
+            rowHeights[row] = Math.max(rowHeights[row], symbolExtent, fontSize);
+        }
+
+        for (let column = 0; column < columns; column++) {
+            columnWidths[column] =
+                columnSymbolExtents[column] +
+                labelOffset +
+                columnLabelWidths[column];
+        }
+
+        /** @type {number[]} */
+        const columnX = [];
+        for (let column = 0, x = 0; column < columns; column++) {
+            columnX[column] = x;
+            x += columnWidths[column] + columnPadding;
+        }
+
+        /** @type {number[]} */
+        const rowY = [];
+        for (let row = 0, y = 0; row < rows; row++) {
+            rowY[row] = y;
+            y += rowHeights[row] + rowPadding;
+        }
+
+        for (let index = 0; index < n; index++) {
+            const datum = this.buffer[index];
+            const entry = entries[index];
+            const x = columnX[entry.column];
+            const y = rowY[entry.row];
+            const symbolSlotWidth = columnSymbolExtents[entry.column];
+            const symbolCenterOffset = symbolSlotWidth / 2;
+
+            datum.row = entry.row;
+            datum.column = entry.column;
+            const entryY = y + yOffset;
+            const labelY = y + yOffset + rowHeights[entry.row] / 2;
+
+            datum.symbolX = x + xOffset + symbolOffset;
+            datum.symbolX2 = x + xOffset + symbolOffset + symbolSlotWidth;
+            datum.entryX = x + xOffset + symbolOffset + symbolCenterOffset;
+            datum.entryY = entryY;
+            datum.entryWidth = columnWidths[entry.column];
+            datum.entryHeight = rowHeights[entry.row];
+            datum.labelX = x + xOffset + symbolSlotWidth + labelOffset;
+            datum.labelY = labelY;
+            if (yExtent != null) {
+                datum.entryY2 = yExtent - entryY;
+                datum.labelY2 = yExtent - labelY;
+            }
+
+            this._propagate(datum);
+        }
+
+        super.complete();
+    }
+}

package/dist/src/data/transforms/transformFactory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transformFactory.d.ts","sourceRoot":"","sources":["../../../../src/data/transforms/transformFactory.js"],"names":[],"mappings":"AA+CA;;;GAGG;AACH,gDAHW,OAAO,yBAAyB,EAAE,mBAAmB,SACrD,OAAO,oBAAoB,EAAE,OAAO,oCAS9C;AAtCD;;;;GAIG;AACH,yBAFU,MAAM,CAAC,MAAM,EAAE,KAAK,MAAM,EAAE,GAAG,EAAE,IAAI,CAAC,EAAE,OAAO,oBAAoB,EAAE,OAAO,KAAK,OAAO,gBAAgB,EAAE,OAAO,CAAC,CAsB1H"}
+{"version":3,"file":"transformFactory.d.ts","sourceRoot":"","sources":["../../../../src/data/transforms/transformFactory.js"],"names":[],"mappings":"AAmDA;;;GAGG;AACH,gDAHW,OAAO,yBAAyB,EAAE,mBAAmB,SACrD,OAAO,oBAAoB,EAAE,OAAO,oCAS9C;AAxCD;;;;GAIG;AACH,yBAFU,MAAM,CAAC,MAAM,EAAE,KAAK,MAAM,EAAE,GAAG,EAAE,IAAI,CAAC,EAAE,OAAO,oBAAoB,EAAE,OAAO,KAAK,OAAO,gBAAgB,EAAE,OAAO,CAAC,CAwB1H"}

package/dist/src/data/transforms/transformFactory.js

@@ -8,6 +8,7 @@ import FlattenDelimitedTransform from "./flattenDelimited.js";
 import FormulaTransform from "./formula.js";
 import LinearizeGenomicCoordinate from "./linearizeGenomicCoordinate.js";
 import MeasureTextTransform from "./measureText.js";
+import PackLegendLabelsTransform from "./packLegendLabels.js";
 import PileupTransform from "./pileup.js";
 import ProjectTransform from "./project.js";
 import RegexExtractTransform from "./regexExtract.js";
@@ -17,6 +18,7 @@ import StackTransform from "./stack.js";
 import FlattenSequenceTransform from "./flattenSequence.js";
 import AggregateTransform from "./aggregate.js";
 import IdentifierTransform from "./identifier.js";
+import TruncateTextTransform from "./truncateText.js";
 
 /**
  * TODO: Make this dynamic
@@ -37,11 +39,13 @@ export const transforms = {
     identifier: IdentifierTransform,
     linearizeGenomicCoordinate: LinearizeGenomicCoordinate,
     measureText: MeasureTextTransform,
+    packLegendLabels: PackLegendLabelsTransform,
     pileup: PileupTransform,
     project: ProjectTransform,
     regexExtract: RegexExtractTransform,
     regexFold: RegexFoldTransform,
     sample: SampleTransform,
+    truncateText: TruncateTextTransform,
     stack: StackTransform,
 };
 

package/dist/src/data/transforms/truncateText.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @param {string} text
+ * @param {number | undefined} limit
+ * @param {((text: string, fontSize?: number) => number) | undefined} measureWidth
+ * @param {number} fontSize
+ * @param {string} ellipsis
+ */
+export function truncateText(text: string, limit: number | undefined, measureWidth: ((text: string, fontSize?: number) => number) | undefined, fontSize: number, ellipsis: string): string;
+export default class TruncateTextTransform extends Transform {
+    /**
+     * @param {import("../../spec/transform.js").TruncateTextParams} params
+     * @param {import("../flowNode.js").ParamRuntimeProvider} paramRuntimeProvider
+     */
+    constructor(params: import("../../spec/transform.js").TruncateTextParams, paramRuntimeProvider: import("../flowNode.js").ParamRuntimeProvider);
+    params: import("../../spec/transform.js").TruncateTextParams;
+    accessor: import("vega-util").AccessorFn<any>;
+    as: string;
+    fontSize: number;
+    ellipsis: string;
+    font: import("../../fonts/bmFontManager.js").FontEntry;
+    /**
+     * @param {any} datum
+     */
+    handle(datum: any): void;
+}
+import Transform from "./transform.js";
+//# sourceMappingURL=truncateText.d.ts.map

package/dist/src/data/transforms/truncateText.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"truncateText.d.ts","sourceRoot":"","sources":["../../../../src/data/transforms/truncateText.js"],"names":[],"mappings":"AAMA;;;;;;GAMG;AACH,mCANW,MAAM,SACN,MAAM,GAAG,SAAS,gBAClB,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC,GAAG,SAAS,YACzD,MAAM,YACN,MAAM,UA+BhB;AAED;IAKI;;;OAGG;IACH,oBAHW,OAAO,yBAAyB,EAAE,kBAAkB,wBACpD,OAAO,gBAAgB,EAAE,oBAAoB,EAUvD;IALG,6DAAoB;IACpB,8CAAmC;IACnC,WAAmC;IACnC,iBAA+B;IAC/B,iBAAmD;IAKnD,uDAMkC;IAGtC;;OAEG;IACH,cAFW,GAAG,QAiBb;CACJ;sBA3FqB,gBAAgB"}