@databricks/sdk-core 0.33.0 → 0.35.0

package/dist/ops/execute.d.ts

@@ -1,10 +1,14 @@
-import type { Options } from './options';
+import { Options } from "./options.js";
+
+//#region src/ops/execute.d.ts
 /**
  * Sleeps for the given duration. It is mostly equivalent to setTimeout, but
  * can be interrupted by the AbortSignal if the signal aborts before the
  * duration elapses.
  */
-export declare function sleep(ms: number, signal?: AbortSignal): Promise<void>;
+declare function sleep(ms: number, signal?: AbortSignal): Promise<void>;
 /** Executes operation op with the given options. */
-export declare function execute(signal: AbortSignal | undefined, op: (signal?: AbortSignal) => Promise<void>, options?: Options): Promise<void>;
+declare function execute(signal: AbortSignal | undefined, op: (signal?: AbortSignal) => Promise<void>, options?: Options): Promise<void>;
+//#endregion
+export { execute, sleep };
 //# sourceMappingURL=execute.d.ts.map

package/dist/ops/execute.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"execute.d.ts","sourceRoot":"","sources":["../../src/ops/execute.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,WAAW,CAAC;AAQvC;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAoBrE;AAKD,oDAAoD;AACpD,wBAAsB,OAAO,CAC3B,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,EAAE,EAAE,CAAC,MAAM,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,IAAI,CAAC,EAC3C,OAAO,CAAC,EAAE,OAAO,GAChB,OAAO,CAAC,IAAI,CAAC,CAGf"}
+{"version":3,"file":"execute.d.ts","names":[],"sources":["../../src/ops/execute.ts"],"mappings":";;;;;AAaA;;;iBAAgB,KAAA,CAAM,EAAA,UAAY,MAAA,GAAS,WAAA,GAAc,OAAA;;iBA0BnC,OAAA,CACpB,MAAA,EAAQ,WAAA,cACR,EAAA,GAAK,MAAA,GAAS,WAAA,KAAgB,OAAA,QAC9B,OAAA,GAAU,OAAA,GACT,OAAA"}

package/dist/ops/execute.js

@@ -1,77 +1,65 @@
-// Coerces an unknown value to an Error instance.
+//#region src/ops/execute.ts
 function toError(value) {
-    return value instanceof Error ? value : new Error(String(value));
+	return value instanceof Error ? value : new Error(String(value));
 }
 /**
- * Sleeps for the given duration. It is mostly equivalent to setTimeout, but
- * can be interrupted by the AbortSignal if the signal aborts before the
- * duration elapses.
- */
-export function sleep(ms, signal) {
-    return new Promise((resolve, reject) => {
-        if (signal?.aborted === true) {
-            reject(toError(signal.reason));
-            return;
-        }
-        if (signal === undefined) {
-            setTimeout(resolve, ms);
-            return;
-        }
-        const onAbort = () => {
-            clearTimeout(timer);
-            reject(toError(signal.reason));
-        };
-        const timer = setTimeout(() => {
-            signal.removeEventListener('abort', onAbort);
-            resolve();
-        }, ms);
-        signal.addEventListener('abort', onAbort, { once: true });
-    });
+* Sleeps for the given duration. It is mostly equivalent to setTimeout, but
+* can be interrupted by the AbortSignal if the signal aborts before the
+* duration elapses.
+*/
+function sleep(ms, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted === true) {
+			reject(toError(signal.reason));
+			return;
+		}
+		if (signal === void 0) {
+			setTimeout(resolve, ms);
+			return;
+		}
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(toError(signal.reason));
+		};
+		const timer = setTimeout(() => {
+			signal.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
 }
 /** Executes operation op with the given options. */
-export async function execute(signal, op, options) {
-    const opts = { ...options };
-    return executeImpl(signal, op, opts, sleep);
+async function execute(signal, op, options) {
+	return executeImpl(signal, op, { ...options }, sleep);
 }
 /**
- * The actual implementation of execute. Its purpose is to ease testing by
- * providing a convenient way to mock the sleeping logic.
- */
+* The actual implementation of execute. Its purpose is to ease testing by
+* providing a convenient way to mock the sleeping logic.
+*/
 async function executeImpl(signal, op, opts, sleep) {
-    // Optionally combine the signal with a timeout signal. If the signal
-    // already has a deadline, that deadline is updated to the minimum of the
-    // signal's deadline and the timeout.
-    if (opts.timeout !== undefined && opts.timeout > 0) {
-        const timeoutSignal = AbortSignal.timeout(opts.timeout);
-        signal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
-    }
-    // Get a new retrier for this specific execution. This is instantiated
-    // lazily if and when the first operation execution returns an error.
-    let retrier;
-    for (;;) {
-        if (opts.rateLimiter) {
-            await opts.rateLimiter.wait(signal);
-        }
-        try {
-            await op(signal);
-            return; // Nothing to retry.
-        }
-        catch (err) {
-            const error = toError(err);
-            if (retrier === undefined) {
-                if (opts.retrier) {
-                    retrier = opts.retrier(); // Lazily instantiate the retrier.
-                }
-                if (retrier === undefined) {
-                    throw error; // No retrier == no retry.
-                }
-            }
-            const delay = retrier.isRetriable(error);
-            if (delay === undefined) {
-                throw error; // Not retriable.
-            }
-            await sleep(delay, signal);
-        }
-    }
+	if (opts.timeout !== void 0 && opts.timeout > 0) {
+		const timeoutSignal = AbortSignal.timeout(opts.timeout);
+		signal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+	}
+	let retrier;
+	for (;;) {
+		if (opts.rateLimiter) await opts.rateLimiter.wait(signal);
+		try {
+			await op(signal);
+			return;
+		} catch (err) {
+			const error = toError(err);
+			if (retrier === void 0) {
+				if (opts.retrier) retrier = opts.retrier();
+				if (retrier === void 0) throw error;
+			}
+			const delay = retrier.isRetriable(error);
+			if (delay === void 0) throw error;
+			await sleep(delay, signal);
+		}
+	}
 }
+
+//#endregion
+export { execute, sleep };
 //# sourceMappingURL=execute.js.map

package/dist/ops/execute.js.map

@@ -1 +1 @@
-{"version":3,"file":"execute.js","sourceRoot":"","sources":["../../src/ops/execute.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"execute.js","names":[],"sources":["../../src/ops/execute.ts"],"sourcesContent":["import type {Options} from './options';\nimport type {Retrier} from './retrier';\n\n// Coerces an unknown value to an Error instance.\nfunction toError(value: unknown): Error {\n  return value instanceof Error ? value : new Error(String(value));\n}\n\n/**\n * Sleeps for the given duration. It is mostly equivalent to setTimeout, but\n * can be interrupted by the AbortSignal if the signal aborts before the\n * duration elapses.\n */\nexport function sleep(ms: number, signal?: AbortSignal): Promise<void> {\n  return new Promise<void>((resolve, reject) => {\n    if (signal?.aborted === true) {\n      reject(toError(signal.reason));\n      return;\n    }\n    if (signal === undefined) {\n      setTimeout(resolve, ms);\n      return;\n    }\n    const onAbort = (): void => {\n      clearTimeout(timer);\n      reject(toError(signal.reason));\n    };\n    const timer = setTimeout(() => {\n      signal.removeEventListener('abort', onAbort);\n      resolve();\n    }, ms);\n    signal.addEventListener('abort', onAbort, {once: true});\n  });\n}\n\n// Sleeper is a convenience type for readability.\ntype Sleeper = (ms: number, signal?: AbortSignal) => Promise<void>;\n\n/** Executes operation op with the given options. */\nexport async function execute(\n  signal: AbortSignal | undefined,\n  op: (signal?: AbortSignal) => Promise<void>,\n  options?: Options\n): Promise<void> {\n  const opts: Options = {...options};\n  return executeImpl(signal, op, opts, sleep);\n}\n\n/**\n * The actual implementation of execute. Its purpose is to ease testing by\n * providing a convenient way to mock the sleeping logic.\n */\nasync function executeImpl(\n  signal: AbortSignal | undefined,\n  op: (signal?: AbortSignal) => Promise<void>,\n  opts: Options,\n  sleep: Sleeper\n): Promise<void> {\n  // Optionally combine the signal with a timeout signal. If the signal\n  // already has a deadline, that deadline is updated to the minimum of the\n  // signal's deadline and the timeout.\n  if (opts.timeout !== undefined && opts.timeout > 0) {\n    const timeoutSignal = AbortSignal.timeout(opts.timeout);\n    signal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;\n  }\n\n  // Get a new retrier for this specific execution. This is instantiated\n  // lazily if and when the first operation execution returns an error.\n  let retrier: Retrier | undefined;\n\n  for (;;) {\n    if (opts.rateLimiter) {\n      await opts.rateLimiter.wait(signal);\n    }\n\n    try {\n      await op(signal);\n      return; // Nothing to retry.\n    } catch (err: unknown) {\n      const error = toError(err);\n\n      if (retrier === undefined) {\n        if (opts.retrier) {\n          retrier = opts.retrier(); // Lazily instantiate the retrier.\n        }\n        if (retrier === undefined) {\n          throw error; // No retrier == no retry.\n        }\n      }\n\n      const delay = retrier.isRetriable(error);\n      if (delay === undefined) {\n        throw error; // Not retriable.\n      }\n\n      await sleep(delay, signal);\n    }\n  }\n}\n"],"mappings":";AAIA,SAAS,QAAQ,OAAuB;AACtC,QAAO,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,MAAM,CAAC;;;;;;;AAQlE,SAAgB,MAAM,IAAY,QAAqC;AACrE,QAAO,IAAI,SAAe,SAAS,WAAW;AAC5C,MAAI,QAAQ,YAAY,MAAM;AAC5B,UAAO,QAAQ,OAAO,OAAO,CAAC;AAC9B;;AAEF,MAAI,WAAW,QAAW;AACxB,cAAW,SAAS,GAAG;AACvB;;EAEF,MAAM,gBAAsB;AAC1B,gBAAa,MAAM;AACnB,UAAO,QAAQ,OAAO,OAAO,CAAC;;EAEhC,MAAM,QAAQ,iBAAiB;AAC7B,UAAO,oBAAoB,SAAS,QAAQ;AAC5C,YAAS;KACR,GAAG;AACN,SAAO,iBAAiB,SAAS,SAAS,EAAC,MAAM,MAAK,CAAC;GACvD;;;AAOJ,eAAsB,QACpB,QACA,IACA,SACe;AAEf,QAAO,YAAY,QAAQ,IADL,EAAC,GAAG,SAAQ,EACG,MAAM;;;;;;AAO7C,eAAe,YACb,QACA,IACA,MACA,OACe;AAIf,KAAI,KAAK,YAAY,UAAa,KAAK,UAAU,GAAG;EAClD,MAAM,gBAAgB,YAAY,QAAQ,KAAK,QAAQ;AACvD,WAAS,SAAS,YAAY,IAAI,CAAC,QAAQ,cAAc,CAAC,GAAG;;CAK/D,IAAI;AAEJ,UAAS;AACP,MAAI,KAAK,YACP,OAAM,KAAK,YAAY,KAAK,OAAO;AAGrC,MAAI;AACF,SAAM,GAAG,OAAO;AAChB;WACO,KAAc;GACrB,MAAM,QAAQ,QAAQ,IAAI;AAE1B,OAAI,YAAY,QAAW;AACzB,QAAI,KAAK,QACP,WAAU,KAAK,SAAS;AAE1B,QAAI,YAAY,OACd,OAAM;;GAIV,MAAM,QAAQ,QAAQ,YAAY,MAAM;AACxC,OAAI,UAAU,OACZ,OAAM;AAGR,SAAM,MAAM,OAAO,OAAO"}

package/dist/ops/index.d.ts

@@ -1,12 +1,5 @@
-/**
- * Utilities to execute Databricks operations with retry, timeout, and rate
- * limiting.
- *
- * @packageDocumentation
- */
-export { execute } from './execute';
-export type { Limiter } from './limiter';
-export type { Options } from './options';
-export { BackoffPolicy, retryOn } from './retrier';
-export type { BackoffPolicyOptions, Retrier } from './retrier';
-//# sourceMappingURL=index.d.ts.map
+import { Limiter } from "./limiter.js";
+import { BackoffPolicy, BackoffPolicyOptions, Retrier, retryOn } from "./retrier.js";
+import { Options } from "./options.js";
+import { execute } from "./execute.js";
+export { BackoffPolicy, type BackoffPolicyOptions, type Limiter, type Options, type Retrier, execute, retryOn };

package/dist/ops/index.js

@@ -1,9 +1,4 @@
-/**
- * Utilities to execute Databricks operations with retry, timeout, and rate
- * limiting.
- *
- * @packageDocumentation
- */
-export { execute } from './execute';
-export { BackoffPolicy, retryOn } from './retrier';
-//# sourceMappingURL=index.js.map
+import { execute } from "./execute.js";
+import { BackoffPolicy, retryOn } from "./retrier.js";
+
+export { BackoffPolicy, execute, retryOn };

package/dist/ops/limiter.d.ts

@@ -1,9 +1,12 @@
+//#region src/ops/limiter.d.ts
 /**
  * Limiter is anything that can wait. It is typically used to implement
  * client-side rate limiting. Implementations of this interface must be
  * safe to call concurrently.
  */
-export interface Limiter {
-    wait(signal?: AbortSignal): Promise<void>;
+interface Limiter {
+  wait(signal?: AbortSignal): Promise<void>;
 }
+//#endregion
+export { Limiter };
 //# sourceMappingURL=limiter.d.ts.map

package/dist/ops/limiter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"limiter.d.ts","sourceRoot":"","sources":["../../src/ops/limiter.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,WAAW,OAAO;IACtB,IAAI,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3C"}
+{"version":3,"file":"limiter.d.ts","names":[],"sources":["../../src/ops/limiter.ts"],"mappings":";;AAKA;;;;UAAiB,OAAA;EACf,IAAA,CAAK,MAAA,GAAS,WAAA,GAAc,OAAA;AAAA"}

package/dist/ops/limiter.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=limiter.js.map

package/dist/ops/options.d.ts

@@ -1,22 +1,26 @@
-import type { Limiter } from './limiter';
-import type { Retrier } from './retrier';
+import { Limiter } from "./limiter.js";
+import { Retrier } from "./retrier.js";
+
+//#region src/ops/options.d.ts
 /** Options that control the behavior of an operation. */
-export interface Options {
-    /**
-     * Provides a new Retrier to be used to execute an operation. The function
-     * is called for each operation and must be safe to call concurrently. The
-     * retrier must be fresh within the context of an execute call (e.g. no
-     * need to reset a BackoffPolicy).
-     */
-    retrier?: (() => Retrier) | undefined;
-    /** The rate limiter used to potentially rate limit the operation. */
-    rateLimiter?: Limiter | undefined;
-    /**
-     * Timeout duration in milliseconds. If the signal already has a deadline,
-     * that deadline is updated to the minimum of the signal's deadline and the
-     * timeout. The timeout covers the whole operation execution; it is not a
-     * timeout for each intermediary call.
-     */
-    timeout?: number | undefined;
+interface Options {
+  /**
+   * Provides a new Retrier to be used to execute an operation. The function
+   * is called for each operation and must be safe to call concurrently. The
+   * retrier must be fresh within the context of an execute call (e.g. no
+   * need to reset a BackoffPolicy).
+   */
+  retrier?: (() => Retrier) | undefined;
+  /** The rate limiter used to potentially rate limit the operation. */
+  rateLimiter?: Limiter | undefined;
+  /**
+   * Timeout duration in milliseconds. If the signal already has a deadline,
+   * that deadline is updated to the minimum of the signal's deadline and the
+   * timeout. The timeout covers the whole operation execution; it is not a
+   * timeout for each intermediary call.
+   */
+  timeout?: number | undefined;
 }
+//#endregion
+export { Options };
 //# sourceMappingURL=options.d.ts.map

package/dist/ops/options.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../src/ops/options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,WAAW,CAAC;AACvC,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,WAAW,CAAC;AAEvC,yDAAyD;AACzD,MAAM,WAAW,OAAO;IACtB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,CAAC,MAAM,OAAO,CAAC,GAAG,SAAS,CAAC;IACtC,qEAAqE;IACrE,WAAW,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAClC;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC9B"}
+{"version":3,"file":"options.d.ts","names":[],"sources":["../../src/ops/options.ts"],"mappings":";;;;;UAIiB,OAAA;EAAA;;;;;;EAOf,OAAA,UAAiB,OAAA;EAEH;EAAd,WAAA,GAAc,OAAA;EAOP;;;;;;EAAP,OAAA;AAAA"}

package/dist/ops/options.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=options.js.map

package/dist/ops/retrier.d.ts

@@ -1,17 +1,18 @@
+//#region src/ops/retrier.d.ts
 /** Options for configuring a {@link BackoffPolicy}. */
-export interface BackoffPolicyOptions {
-    /** Initial delay in milliseconds; defaults to 1000. */
-    initial?: number;
-    /** Maximum delay in milliseconds; defaults to 60000. */
-    maximum?: number;
-    /**
-     * Factor by which the delay is multiplied after each retry. The value must
-     * be greater or equal to 1. If not, it defaults to 2.
-     */
-    factor?: number;
+interface BackoffPolicyOptions {
+  /** Initial delay in milliseconds; defaults to 1000. */
+  initial?: number;
+  /** Maximum delay in milliseconds; defaults to 60000. */
+  maximum?: number;
+  /**
+   * Factor by which the delay is multiplied after each retry. The value must
+   * be greater or equal to 1. If not, it defaults to 2.
+   */
+  factor?: number;
 }
-export declare const rand: {
-    int(n: number): number;
+declare const rand: {
+  int(n: number): number;
 };
 /**
  * BackoffPolicy implements an exponential backoff policy. The delay between
@@ -25,26 +26,26 @@ export declare const rand: {
  *
  * [Exponential Backoff And Jitter]: https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/
  */
-export declare class BackoffPolicy {
-    /** Initial delay in milliseconds. */
-    readonly initial: number;
-    /** Maximum delay in milliseconds. */
-    readonly maximum: number;
-    /** Factor by which the delay is multiplied after each retry. */
-    readonly factor: number;
-    private current;
-    constructor(options?: BackoffPolicyOptions);
-    /** Returns a random delay in [0, current] and grows the current delay. */
-    delay(): number;
+declare class BackoffPolicy {
+  /** Initial delay in milliseconds. */
+  readonly initial: number;
+  /** Maximum delay in milliseconds. */
+  readonly maximum: number;
+  /** Factor by which the delay is multiplied after each retry. */
+  readonly factor: number;
+  private current;
+  constructor(options?: BackoffPolicyOptions);
+  /** Returns a random delay in [0, current] and grows the current delay. */
+  delay(): number;
 }
 /** Retrier defines a retry behavior. */
-export interface Retrier {
-    /**
-     * Returns the delay in milliseconds before the next retry, or undefined if
-     * the error is not retriable. Implementations should assume that the given
-     * error is never undefined.
-     */
-    isRetriable(err: Error): number | undefined;
+interface Retrier {
+  /**
+   * Returns the delay in milliseconds before the next retry, or undefined if
+   * the error is not retriable. Implementations should assume that the given
+   * error is never undefined.
+   */
+  isRetriable(err: Error): number | undefined;
 }
 /**
  * Returns a Retrier that retries based on the isRetriable predicate and relies
@@ -54,5 +55,7 @@ export interface Retrier {
  * reset by design. Users who need to reset the backoff policy should rather
  * create a new retrier.
  */
-export declare function retryOn(options: BackoffPolicyOptions, isRetriable: (err: Error) => boolean): Retrier;
+declare function retryOn(options: BackoffPolicyOptions, isRetriable: (err: Error) => boolean): Retrier;
+//#endregion
+export { BackoffPolicy, BackoffPolicyOptions, Retrier, rand, retryOn };
 //# sourceMappingURL=retrier.d.ts.map

package/dist/ops/retrier.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"retrier.d.ts","sourceRoot":"","sources":["../../src/ops/retrier.ts"],"names":[],"mappings":"AAAA,uDAAuD;AACvD,MAAM,WAAW,oBAAoB;IACnC,uDAAuD;IACvD,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,wDAAwD;IACxD,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAGD,eAAO,MAAM,IAAI;WAER,MAAM,GAAG,MAAM;CAGvB,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,qBAAa,aAAa;IACxB,qCAAqC;IACrC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAEzB,qCAAqC;IACrC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAEzB,gEAAgE;IAChE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAGxB,OAAO,CAAC,OAAO,CAAS;gBAEZ,OAAO,CAAC,EAAE,oBAAoB;IAgB1C,0EAA0E;IAC1E,KAAK,IAAI,MAAM;CAShB;AAED,wCAAwC;AACxC,MAAM,WAAW,OAAO;IACtB;;;;OAIG;IACH,WAAW,CAAC,GAAG,EAAE,KAAK,GAAG,MAAM,GAAG,SAAS,CAAC;CAC7C;AAED;;;;;;;GAOG;AACH,wBAAgB,OAAO,CACrB,OAAO,EAAE,oBAAoB,EAC7B,WAAW,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,OAAO,GACnC,OAAO,CAUT"}
+{"version":3,"file":"retrier.d.ts","names":[],"sources":["../../src/ops/retrier.ts"],"mappings":";;UACiB,oBAAA;EAAoB;EAEnC,OAAA;EAFmC;EAKnC,OAAA;EAAA;;;;EAMA,MAAA;AAAA;AAAA,cAIW,IAAA;EAKZ,GAAA,CAAA,CAAA;AAAA;AAcD;;;;;;;;;;;;AAAA,cAAa,aAAA;EA8BN;EAAA,SA5BI,OAAA;EAwCa;EAAA,SArCb,OAAA;EA2Ca;EAAA,SAxCb,MAAA;EAAA,QAGD,OAAA;cAEI,OAAA,GAAU,oBAAA;EAmCA;EAlBtB,KAAA,CAAA;AAAA;;UAYe,OAAA;EAkBN;;;;;EAZT,WAAA,CAAY,GAAA,EAAK,KAAA;AAAA;;;;;;;;;iBAWH,OAAA,CACd,OAAA,EAAS,oBAAA,EACT,WAAA,GAAc,GAAA,EAAK,KAAA,eAClB,OAAA"}

package/dist/ops/retrier.js

@@ -1,70 +1,59 @@
-// Random number generation, wrapped in an object for testability.
-export const rand = {
-    // Returns a random integer in [0, n).
-    int(n) {
-        return Math.floor(Math.random() * n);
-    },
-};
+//#region src/ops/retrier.ts
+const rand = { int(n) {
+	return Math.floor(Math.random() * n);
+} };
 /**
- * BackoffPolicy implements an exponential backoff policy. The delay between
- * retries is randomly computed between 0 and the "exponential delay" as
- * recommended in [Exponential Backoff And Jitter]. The retry delay starts from
- * initial and grows exponentially by factor at every retry. The maximum retry
- * delay is capped by maximum.
- *
- * There is no parameter to limit the number of retries. This is intended as
- * such logic should be implemented upstream (e.g. in a Retrier).
- *
- * [Exponential Backoff And Jitter]: https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/
- */
-export class BackoffPolicy {
-    /** Initial delay in milliseconds. */
-    initial;
-    /** Maximum delay in milliseconds. */
-    maximum;
-    /** Factor by which the delay is multiplied after each retry. */
-    factor;
-    // Current delay before the next retry.
-    current;
-    constructor(options) {
-        let initial = options?.initial ?? 1000; // Default initial delay of 1 second.
-        const maximum = options?.maximum ?? 60000; // Default maximum delay of 60 seconds.
-        if (initial > maximum) {
-            // Initial cannot be greater than maximum.
-            initial = maximum;
-        }
-        this.initial = initial;
-        this.maximum = maximum;
-        this.factor =
-            options?.factor !== undefined && options.factor >= 1 ? options.factor : 2;
-        this.current = this.initial;
-    }
-    /** Returns a random delay in [0, current] and grows the current delay. */
-    delay() {
-        // Random duration in the range [0, this.current].
-        const d = rand.int(this.current + 1);
-        // Grow delay for the next call.
-        this.current = Math.min(this.current * this.factor, this.maximum);
-        return d;
-    }
-}
+* BackoffPolicy implements an exponential backoff policy. The delay between
+* retries is randomly computed between 0 and the "exponential delay" as
+* recommended in [Exponential Backoff And Jitter]. The retry delay starts from
+* initial and grows exponentially by factor at every retry. The maximum retry
+* delay is capped by maximum.
+*
+* There is no parameter to limit the number of retries. This is intended as
+* such logic should be implemented upstream (e.g. in a Retrier).
+*
+* [Exponential Backoff And Jitter]: https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/
+*/
+var BackoffPolicy = class {
+	/** Initial delay in milliseconds. */
+	initial;
+	/** Maximum delay in milliseconds. */
+	maximum;
+	/** Factor by which the delay is multiplied after each retry. */
+	factor;
+	current;
+	constructor(options) {
+		let initial = options?.initial ?? 1e3;
+		const maximum = options?.maximum ?? 6e4;
+		if (initial > maximum) initial = maximum;
+		this.initial = initial;
+		this.maximum = maximum;
+		this.factor = options?.factor !== void 0 && options.factor >= 1 ? options.factor : 2;
+		this.current = this.initial;
+	}
+	/** Returns a random delay in [0, current] and grows the current delay. */
+	delay() {
+		const d = rand.int(this.current + 1);
+		this.current = Math.min(this.current * this.factor, this.maximum);
+		return d;
+	}
+};
 /**
- * Returns a Retrier that retries based on the isRetriable predicate and relies
- * on an internal backoff policy to decide how long to wait between retries.
- *
- * Important: the retrier has its own backoff policy which cannot be trivially
- * reset by design. Users who need to reset the backoff policy should rather
- * create a new retrier.
- */
-export function retryOn(options, isRetriable) {
-    const bp = new BackoffPolicy(options);
-    return {
-        isRetriable(err) {
-            if (!isRetriable(err)) {
-                return undefined;
-            }
-            return bp.delay();
-        },
-    };
+* Returns a Retrier that retries based on the isRetriable predicate and relies
+* on an internal backoff policy to decide how long to wait between retries.
+*
+* Important: the retrier has its own backoff policy which cannot be trivially
+* reset by design. Users who need to reset the backoff policy should rather
+* create a new retrier.
+*/
+function retryOn(options, isRetriable) {
+	const bp = new BackoffPolicy(options);
+	return { isRetriable(err) {
+		if (!isRetriable(err)) return;
+		return bp.delay();
+	} };
 }
+
+//#endregion
+export { BackoffPolicy, rand, retryOn };
 //# sourceMappingURL=retrier.js.map

package/dist/ops/retrier.js.map

@@ -1 +1 @@
-{"version":3,"file":"retrier.js","sourceRoot":"","sources":["../../src/ops/retrier.ts"],"names":[],"mappings":"AAeA,kEAAkE;AAClE,MAAM,CAAC,MAAM,IAAI,GAAG;IAClB,sCAAsC;IACtC,GAAG,CAAC,CAAS;QACX,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;IACvC,CAAC;CACF,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,MAAM,OAAO,aAAa;IACxB,qCAAqC;IAC5B,OAAO,CAAS;IAEzB,qCAAqC;IAC5B,OAAO,CAAS;IAEzB,gEAAgE;IACvD,MAAM,CAAS;IAExB,uCAAuC;IAC/B,OAAO,CAAS;IAExB,YAAY,OAA8B;QACxC,IAAI,OAAO,GAAG,OAAO,EAAE,OAAO,IAAI,IAAI,CAAC,CAAC,qCAAqC;QAC7E,MAAM,OAAO,GAAG,OAAO,EAAE,OAAO,IAAI,KAAK,CAAC,CAAC,uCAAuC;QAElF,IAAI,OAAO,GAAG,OAAO,EAAE,CAAC;YACtB,0CAA0C;YAC1C,OAAO,GAAG,OAAO,CAAC;QACpB,CAAC;QAED,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,MAAM;YACT,OAAO,EAAE,MAAM,KAAK,SAAS,IAAI,OAAO,CAAC,MAAM,IAAI,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;QAC5E,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;IAC9B,CAAC;IAED,0EAA0E;IAC1E,KAAK;QACH,kDAAkD;QAClD,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC;QAErC,gCAAgC;QAChC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;QAElE,OAAO,CAAC,CAAC;IACX,CAAC;CACF;AAYD;;;;;;;GAOG;AACH,MAAM,UAAU,OAAO,CACrB,OAA6B,EAC7B,WAAoC;IAEpC,MAAM,EAAE,GAAG,IAAI,aAAa,CAAC,OAAO,CAAC,CAAC;IACtC,OAAO;QACL,WAAW,CAAC,GAAU;YACpB,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,CAAC;gBACtB,OAAO,SAAS,CAAC;YACnB,CAAC;YACD,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC;QACpB,CAAC;KACF,CAAC;AACJ,CAAC"}
+{"version":3,"file":"retrier.js","names":[],"sources":["../../src/ops/retrier.ts"],"sourcesContent":["/** Options for configuring a {@link BackoffPolicy}. */\nexport interface BackoffPolicyOptions {\n  /** Initial delay in milliseconds; defaults to 1000. */\n  initial?: number;\n\n  /** Maximum delay in milliseconds; defaults to 60000. */\n  maximum?: number;\n\n  /**\n   * Factor by which the delay is multiplied after each retry. The value must\n   * be greater or equal to 1. If not, it defaults to 2.\n   */\n  factor?: number;\n}\n\n// Random number generation, wrapped in an object for testability.\nexport const rand = {\n  // Returns a random integer in [0, n).\n  int(n: number): number {\n    return Math.floor(Math.random() * n);\n  },\n};\n\n/**\n * BackoffPolicy implements an exponential backoff policy. The delay between\n * retries is randomly computed between 0 and the \"exponential delay\" as\n * recommended in [Exponential Backoff And Jitter]. The retry delay starts from\n * initial and grows exponentially by factor at every retry. The maximum retry\n * delay is capped by maximum.\n *\n * There is no parameter to limit the number of retries. This is intended as\n * such logic should be implemented upstream (e.g. in a Retrier).\n *\n * [Exponential Backoff And Jitter]: https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/\n */\nexport class BackoffPolicy {\n  /** Initial delay in milliseconds. */\n  readonly initial: number;\n\n  /** Maximum delay in milliseconds. */\n  readonly maximum: number;\n\n  /** Factor by which the delay is multiplied after each retry. */\n  readonly factor: number;\n\n  // Current delay before the next retry.\n  private current: number;\n\n  constructor(options?: BackoffPolicyOptions) {\n    let initial = options?.initial ?? 1000; // Default initial delay of 1 second.\n    const maximum = options?.maximum ?? 60000; // Default maximum delay of 60 seconds.\n\n    if (initial > maximum) {\n      // Initial cannot be greater than maximum.\n      initial = maximum;\n    }\n\n    this.initial = initial;\n    this.maximum = maximum;\n    this.factor =\n      options?.factor !== undefined && options.factor >= 1 ? options.factor : 2;\n    this.current = this.initial;\n  }\n\n  /** Returns a random delay in [0, current] and grows the current delay. */\n  delay(): number {\n    // Random duration in the range [0, this.current].\n    const d = rand.int(this.current + 1);\n\n    // Grow delay for the next call.\n    this.current = Math.min(this.current * this.factor, this.maximum);\n\n    return d;\n  }\n}\n\n/** Retrier defines a retry behavior. */\nexport interface Retrier {\n  /**\n   * Returns the delay in milliseconds before the next retry, or undefined if\n   * the error is not retriable. Implementations should assume that the given\n   * error is never undefined.\n   */\n  isRetriable(err: Error): number | undefined;\n}\n\n/**\n * Returns a Retrier that retries based on the isRetriable predicate and relies\n * on an internal backoff policy to decide how long to wait between retries.\n *\n * Important: the retrier has its own backoff policy which cannot be trivially\n * reset by design. Users who need to reset the backoff policy should rather\n * create a new retrier.\n */\nexport function retryOn(\n  options: BackoffPolicyOptions,\n  isRetriable: (err: Error) => boolean\n): Retrier {\n  const bp = new BackoffPolicy(options);\n  return {\n    isRetriable(err: Error): number | undefined {\n      if (!isRetriable(err)) {\n        return undefined;\n      }\n      return bp.delay();\n    },\n  };\n}\n"],"mappings":";AAgBA,MAAa,OAAO,EAElB,IAAI,GAAmB;AACrB,QAAO,KAAK,MAAM,KAAK,QAAQ,GAAG,EAAE;GAEvC;;;;;;;;;;;;;AAcD,IAAa,gBAAb,MAA2B;;CAEzB,AAAS;;CAGT,AAAS;;CAGT,AAAS;CAGT,AAAQ;CAER,YAAY,SAAgC;EAC1C,IAAI,UAAU,SAAS,WAAW;EAClC,MAAM,UAAU,SAAS,WAAW;AAEpC,MAAI,UAAU,QAEZ,WAAU;AAGZ,OAAK,UAAU;AACf,OAAK,UAAU;AACf,OAAK,SACH,SAAS,WAAW,UAAa,QAAQ,UAAU,IAAI,QAAQ,SAAS;AAC1E,OAAK,UAAU,KAAK;;;CAItB,QAAgB;EAEd,MAAM,IAAI,KAAK,IAAI,KAAK,UAAU,EAAE;AAGpC,OAAK,UAAU,KAAK,IAAI,KAAK,UAAU,KAAK,QAAQ,KAAK,QAAQ;AAEjE,SAAO;;;;;;;;;;;AAsBX,SAAgB,QACd,SACA,aACS;CACT,MAAM,KAAK,IAAI,cAAc,QAAQ;AACrC,QAAO,EACL,YAAY,KAAgC;AAC1C,MAAI,CAAC,YAAY,IAAI,CACnB;AAEF,SAAO,GAAG,OAAO;IAEpB"}

package/dist/package.js

@@ -0,0 +1,6 @@
+//#region package.json
+var version = "0.35.0";
+
+//#endregion
+export { version };
+//# sourceMappingURL=package.js.map

package/dist/package.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"package.js","names":[],"sources":["../package.json"],"sourcesContent":[""],"mappings":""}

package/dist/profiles/errors.d.ts

@@ -1,17 +1,20 @@
+//#region src/profiles/errors.d.ts
 /**
  * Error types for Databricks configuration profile operations.
  *
  * @module
  */
 /** Discriminant codes for {@link ProfileError}. */
-export type ProfileErrorCode = 'CONFIG_FILE_NOT_FOUND' | 'PROFILE_NOT_FOUND' | 'EMPTY_PATH' | 'EMPTY_PROFILE' | 'INVALID_PROFILE_NAME' | 'CONFLICTING_OPTIONS';
+type ProfileErrorCode = 'CONFIG_FILE_NOT_FOUND' | 'PROFILE_NOT_FOUND' | 'EMPTY_PATH' | 'EMPTY_PROFILE' | 'INVALID_PROFILE_NAME' | 'CONFLICTING_OPTIONS';
 /**
  * Error thrown by profile operations.
  *
  * Use the {@link ProfileError.code} field to distinguish between error causes.
  */
-export declare class ProfileError extends Error {
-    readonly code: ProfileErrorCode;
-    constructor(code: ProfileErrorCode, message: string);
+declare class ProfileError extends Error {
+  readonly code: ProfileErrorCode;
+  constructor(code: ProfileErrorCode, message: string);
 }
+//#endregion
+export { ProfileError, ProfileErrorCode };
 //# sourceMappingURL=errors.d.ts.map

package/dist/profiles/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/profiles/errors.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,mDAAmD;AACnD,MAAM,MAAM,gBAAgB,GACxB,uBAAuB,GACvB,mBAAmB,GACnB,YAAY,GACZ,eAAe,GACf,sBAAsB,GACtB,qBAAqB,CAAC;AAE1B;;;;GAIG;AACH,qBAAa,YAAa,SAAQ,KAAK;IACrC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;gBAEpB,IAAI,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM;CAKpD"}
+{"version":3,"file":"errors.d.ts","names":[],"sources":["../../src/profiles/errors.ts"],"mappings":";;AAOA;;;;;KAAY,gBAAA;;;;;;cAaC,YAAA,SAAqB,KAAA;EAAA,SACvB,IAAA,EAAM,gBAAA;cAEH,IAAA,EAAM,gBAAA,EAAkB,OAAA;AAAA"}

package/dist/profiles/errors.js

@@ -1,19 +1,18 @@
+//#region src/profiles/errors.ts
 /**
- * Error types for Databricks configuration profile operations.
- *
- * @module
- */
-/**
- * Error thrown by profile operations.
- *
- * Use the {@link ProfileError.code} field to distinguish between error causes.
- */
-export class ProfileError extends Error {
-    code;
-    constructor(code, message) {
-        super(message);
-        this.name = 'ProfileError';
-        this.code = code;
-    }
-}
+* Error thrown by profile operations.
+*
+* Use the {@link ProfileError.code} field to distinguish between error causes.
+*/
+var ProfileError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "ProfileError";
+		this.code = code;
+	}
+};
+
+//#endregion
+export { ProfileError };
 //# sourceMappingURL=errors.js.map