@kong-ui-public/analytics-utilities 14.2.2-pr.3992.307487082.0 → 14.2.3

package/dist/types/captureProtocol.d.ts

@@ -0,0 +1,28 @@
+export declare const CAPTURE_PREPARE_EVENT = "kapture:prepare";
+export declare const CAPTURE_RESTORE_EVENT = "kapture:restore";
+export interface CapturePrepareDetail {
+    waitUntil: (promise: Promise<void>) => void;
+}
+export declare function prepareForCapture(): Promise<void>;
+export declare function restoreAfterCapture(): void;
+export type CaptureRestore = (() => void) | void;
+/**
+ * Use this for anything that isn't a plain WebGL canvas. For WebGL
+ * canvases use {@link registerWebglCapture} instead.
+ *
+ * @param prepare Runs when a capture starts; Return a {@link CaptureRestore} to undo itself
+ * @returns An unregister function, **call it on unmount!**
+ */
+export declare function registerCapture(prepare: () => Promise<CaptureRestore> | CaptureRestore): () => void;
+export interface WebglCaptureOptions {
+    redraw?: () => void;
+}
+/**
+ * This will temporarily swap the canvas for a static <img> while capturing.
+ *
+ * @param getCanvas Returns the canvas to capture
+ * @param options See {@link WebglCaptureOptions}
+ * @returns An unregister function, **call it on unmount!**
+ */
+export declare function registerWebglCapture(getCanvas: () => HTMLCanvasElement | null | undefined, options?: WebglCaptureOptions): () => void;
+//# sourceMappingURL=captureProtocol.d.ts.map

package/dist/types/captureProtocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"captureProtocol.d.ts","sourceRoot":"","sources":["../../src/captureProtocol.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,qBAAqB,oBAAoB,CAAA;AACtD,eAAO,MAAM,qBAAqB,oBAAoB,CAAA;AAEtD,MAAM,WAAW,oBAAoB;IAEnC,SAAS,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,KAAK,IAAI,CAAA;CAC5C;AAED,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC,CAQvD;AAED,wBAAgB,mBAAmB,IAAI,IAAI,CAE1C;AAGD,MAAM,MAAM,cAAc,GAAG,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAAA;AAEhD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,OAAO,CAAC,cAAc,CAAC,GAAG,cAAc,GACtD,MAAM,IAAI,CAyBZ;AAED,MAAM,WAAW,mBAAmB;IAIlC,MAAM,CAAC,EAAE,MAAM,IAAI,CAAA;CACpB;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,MAAM,iBAAiB,GAAG,IAAI,GAAG,SAAS,EACrD,OAAO,GAAE,mBAAwB,GAChC,MAAM,IAAI,CA0BZ"}

package/dist/types/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const REFRESH_INTERVAL_MS: number;
+export declare const EXPORT_RECORD_LIMIT = 1000;
+export declare const INJECT_QUERY_PROVIDER = "analytics-query-provider";
+//# sourceMappingURL=constants.d.ts.map

package/dist/types/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mBAAmB,QAAY,CAAA;AAE5C,eAAO,MAAM,mBAAmB,OAAO,CAAA;AAEvC,eAAO,MAAM,qBAAqB,6BAA6B,CAAA"}

package/dist/types/coordination/color-overrides.d.ts

@@ -0,0 +1,7 @@
+export type ColorMap = Record<string, string>;
+export type ColorState = 'empty' | 'warning' | 'error' | 'neutral' | '____OTHER____';
+export declare const statusCodeColors: ColorMap;
+export declare const unknownStatusCodeColors: ColorMap;
+export declare const statusCodeGroupColors: ColorMap;
+export declare const stateColors: Record<ColorState, string>;
+//# sourceMappingURL=color-overrides.d.ts.map

package/dist/types/coordination/color-overrides.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"color-overrides.d.ts","sourceRoot":"","sources":["../../../src/coordination/color-overrides.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAC7C,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,GAAG,eAAe,CAAA;AAEpF,eAAO,MAAM,gBAAgB,EAAE,QA+D9B,CAAA;AAED,eAAO,MAAM,uBAAuB,EAAE,QAMrC,CAAA;AAED,eAAO,MAAM,qBAAqB,EAAE,QAMnC,CAAA;AAED,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,UAAU,EAAE,MAAM,CAMlD,CAAA"}

package/dist/types/coordination/color.d.ts

@@ -0,0 +1,54 @@
+import { type ColorState } from './color-overrides';
+import type { ColorCoordinator } from '../types/interaction-coordinator';
+export declare const lightPalette: string[];
+export declare const darkPalette: string[];
+export declare const generateDiscriminator: (id: string) => number;
+/**
+ * Returns the palette that `color()`/`colorByDiscriminator()` will index into for
+ * the given theme. Useful for callers (e.g. a color coordinator) that need to
+ * know the palette length in order to assign and spread discriminator indices
+ * consistently with how colors are ultimately resolved.
+ */
+export declare const getActivePalette: ({ theme, }?: {
+    theme?: "light" | "dark";
+}) => string[];
+export declare const colorByDiscriminator: ({ discriminator, theme, }: {
+    discriminator: number;
+    theme?: "light" | "dark";
+}) => string;
+export declare const colorByState: ({ state, }: {
+    state: ColorState;
+}) => string;
+export declare const colorByStatusCode: ({ statusCode, }: {
+    statusCode: string | number;
+}) => string;
+export declare const colorByStatusCodeGroup: ({ group, }: {
+    group: string;
+}) => string;
+export declare const color: ({ discriminator, state, dimension, dimensionValue, metric, coordinator, order, chartUuid, customDimensionColors, }: {
+    discriminator?: number;
+    state?: ColorState;
+    dimension?: string;
+    dimensionValue?: string;
+    metric?: string;
+    /**
+     * An optional cross-chart color coordinator (e.g. from
+     * `useInteractionCoordinator().color`). When provided, generic series colors
+     * are assigned through it so they stay consistent across charts and distinct
+     * within a chart. Has no effect on override colors (status codes, states,
+     * empty/other) or when an explicit `discriminator` is given.
+     */
+    coordinator?: ColorCoordinator;
+    /**
+     * This series' rank within its chart (e.g. 1 for the highest value). Used by
+     * the coordinator to avoid giving adjacent series the same color.
+     */
+    order?: number;
+    /**
+     * The uuid of the chart requesting the color. Allows the coordinator to
+       * correctly group a chart's series when avoiding adjacent collisions.
+     */
+    chartUuid?: string;
+    customDimensionColors?: Record<string, string>;
+}) => string;
+//# sourceMappingURL=color.d.ts.map

package/dist/types/coordination/color.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"color.d.ts","sourceRoot":"","sources":["../../../src/coordination/color.ts"],"names":[],"mappings":"AAEA,OAAO,EAKL,KAAK,UAAU,EAChB,MAAM,mBAAmB,CAAA;AAE1B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAA;AAGxE,eAAO,MAAM,YAAY,UAQxB,CAAA;AAED,eAAO,MAAM,WAAW,UAQvB,CAAA;AAED,eAAO,MAAM,qBAAqB,GAAI,IAAI,MAAM,KAAG,MAAkB,CAAA;AAErE;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,GAAI,aAE9B;IACD,KAAK,CAAC,EAAE,OAAO,GAAG,MAAM,CAAA;CACpB,KAAG,MAAM,EAEd,CAAA;AAED,eAAO,MAAM,oBAAoB,GAAI,2BAGlC;IACD,aAAa,EAAE,MAAM,CAAA;IACrB,KAAK,CAAC,EAAE,OAAO,GAAG,MAAM,CAAA;CACzB,KAAG,MAMH,CAAA;AAED,eAAO,MAAM,YAAY,GAAI,YAE1B;IACD,KAAK,EAAE,UAAU,CAAA;CAClB,KAAG,MAEH,CAAA;AAED,eAAO,MAAM,iBAAiB,GAAI,iBAE/B;IACD,UAAU,EAAE,MAAM,GAAG,MAAM,CAAA;CAC5B,KAAG,MAQH,CAAA;AAED,eAAO,MAAM,sBAAsB,GAAI,YAEpC;IACD,KAAK,EAAE,MAAM,CAAA;CACd,KAAG,MAIH,CAAA;AAED,eAAO,MAAM,KAAK,GAAI,oHAUnB;IACD,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,KAAK,CAAC,EAAE,UAAU,CAAA;IAClB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,gBAAgB,CAAA;IAC9B;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IACd;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,qBAAqB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC/C,KAAG,MAuDH,CAAA"}

package/dist/types/coordination/djb2.d.ts

@@ -0,0 +1,11 @@
+/**
+ * This hashes a string and turns it into a positive integer very quickly. It is
+ * relatively decent at generating values that are distributed evenly. However,
+ * it is NOT cryptographically secure in any way. Used to turn a string into a
+ * consistent number.
+ *
+ * implementation from: https://gist.github.com/eplawless/52813b1d8ad9af510d85?permalink_comment_id=3367765
+ * use case article: https://mojoauth.com/hashing/bernsteins-hash-djb2-in-javascript-in-browser#use-cases-for-bernsteins-hash-djb2
+ */
+export declare const djb2: (str: string) => number;
+//# sourceMappingURL=djb2.d.ts.map

package/dist/types/coordination/djb2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"djb2.d.ts","sourceRoot":"","sources":["../../../src/coordination/djb2.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,eAAO,MAAM,IAAI,GAAI,KAAK,MAAM,KAAG,MAQlC,CAAA"}

package/dist/types/coordination/index.d.ts

@@ -0,0 +1,4 @@
+export { default as useInteractionCoordinator } from './useInteractionCoordinator';
+export * from './color';
+export * from './djb2';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/coordination/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/coordination/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,yBAAyB,EAAE,MAAM,6BAA6B,CAAA;AAClF,cAAc,SAAS,CAAA;AACvB,cAAc,QAAQ,CAAA"}

package/dist/types/coordination/useColorCoordinator.d.ts

@@ -0,0 +1,21 @@
+import type { ColorCoordinator } from '../types';
+/**
+ * Coordinates series colors across multiple charts
+ *
+ * Intended to be composed privately by `useInteractionCoordinator` and exposed
+ * under its `color` namespace. State here is deliberately plain (non-reactive):
+ * charts resolve each color once at render time and freeze it.
+ *
+ * The algorithm is incremental, append-only, and locked-on-first-assignment:
+ *  - A series string is keyed by its value, so the same string always resolves
+ *    to the same palette index across every chart (consistency).
+ *  - When a newly seen string is resolved, it is given the least-used palette
+ *    index, avoiding the color of the immediately preceding series of the same
+ *    chart (adjacency), then locked.
+ *  - Because the palette has several colors and we only ever forbid one neighbor,
+ *    a newly assigned string can always avoid colliding with the previous series.
+ *    The only adjacent collisions that can occur are those inherited from strings
+ *    already locked by an earlier-loading chart.
+ */
+export default function useColorCoordinator(): ColorCoordinator;
+//# sourceMappingURL=useColorCoordinator.d.ts.map

package/dist/types/coordination/useColorCoordinator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useColorCoordinator.d.ts","sourceRoot":"","sources":["../../../src/coordination/useColorCoordinator.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,gBAAgB,EAEjB,MAAM,UAAU,CAAA;AAIjB;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,OAAO,UAAU,mBAAmB,IAAI,gBAAgB,CA6F9D"}

package/dist/types/coordination/useInteractionCoordinator.d.ts

@@ -0,0 +1,25 @@
+import type { InteractionCoordinator } from '../types';
+/**
+ * The interaction coordinator is used for
+ *
+ * * reporting any interaction between a user and a chart so that other charts
+ *     can react to it
+ * * coordinating multiple charts to use the same colors while minimizing
+ *     sequential series with the same color
+ *
+ * Use one instance of the coordinator for each logical grouping of charts. So,
+ * dashboards use `provide`/`inject` to provide an instance of this coordinator
+ * to each of its charts. Each of those charts then calls the color util with
+ * that instance.
+ *
+ * Within each chart component we `watch` the things that we want the component
+ * to react to (e.g. `watch(coordinatorInstance.activeDimension, (dim) =>
+ * highlight(dim)`). Also each of those chart components call `activate` when
+ * the user interacts with them.
+ *
+ * For performance concerns, please try to respect the `<foo>_DEBOUNCE_MS` constants
+ * so that we're only firing certain kinds of interaction (and thereby triggering
+ * redraws and updates) no more frequently than those constants suggest.
+ */
+export default function useInteractionCoordinator(): InteractionCoordinator;
+//# sourceMappingURL=useInteractionCoordinator.d.ts.map

package/dist/types/coordination/useInteractionCoordinator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInteractionCoordinator.d.ts","sourceRoot":"","sources":["../../../src/coordination/useInteractionCoordinator.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,sBAAsB,EAGvB,MAAM,UAAU,CAAA;AAEjB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,OAAO,UAAU,yBAAyB,IAAI,sBAAsB,CAmD1E"}