@schibsted/account-sdk-browser 5.2.7 → 6.0.0-alpha.10

package/src/{validate.js → validate.ts}

@@ -2,9 +2,7 @@
  * See LICENSE.md in the project root.
  */
 
-'use strict';
-
-import SDKError from './SDKError.js';
+import SDKError from './sdk-error.js';
 
 /*
  * This module defines a set of validation functions which are used in the rest of the SDK.
@@ -16,13 +14,13 @@ import SDKError from './SDKError.js';
 /**
  * A utility function that throws an SDKError if an assertion fails. It's mostly useful for
  * validating function inputs.
- * @memberof core
- * @param {boolean} condition - The condition that we're asserting
- * @param {string} [message = Assertion failed] - The error message
+ *
+ * Narrows `condition` for the rest of the enclosing scope (TypeScript assertion signature).
+ * @param condition - The condition that we're asserting
+ * @param message - The error message
  * @throws {SDKError} - If the condition is falsy it throws the appropriate error
- * @return {void}
  */
-export function assert(condition, message = 'Assertion failed') {
+export function assert(condition: boolean, message = 'Assertion failed'): asserts condition {
     if (!condition) {
         throw new SDKError(message);
     }
@@ -30,82 +28,68 @@ export function assert(condition, message = 'Assertion failed') {
 
 /**
  * Checks if a value is a string or not
- * @memberof core
- * @param {*} value - The value to check
- * @return {boolean}
+ * @param value - The value to check
  */
-export function isStr(value) {
+export function isStr(value: unknown): value is string {
     return typeof value === 'string';
 }
 
 /**
  * Checks if a value is a non-empty string
- * @memberof core
- * @param {*} value - The value to check
- * @return {boolean}
+ * @param value - The value to check
  */
-export function isNonEmptyString(value) {
+export function isNonEmptyString(value: unknown): value is string {
     return typeof value === 'string' && value.length > 0;
 }
 
 /**
  * checks if a given value is an object (but not null)
- * @memberof core
- * @param {*} value - The value to check
- * @return {boolean}
+ * @param value - The value to check
  */
-export function isObject(value) {
+export function isObject(value: unknown): value is Record<string, unknown> {
     return typeof value === 'object' && value !== null;
 }
 
 /**
  * Checks if a given value is an object with at least one own key
- * @memberof core
- * @param {*} value - The value to check
- * @return {boolean}
+ * @param value - The value to check
  */
-export function isNonEmptyObj(value) {
+export function isNonEmptyObj(value: unknown): value is Record<string, unknown> {
     return isObject(value) && Object.keys(value).length > 0;
 }
 
 /**
  * Checks if a given string is a valid URL
- * @memberof core
- * @param {string} value - The string to be tested
- * @param {...string} mandatoryFields - A list of mandatory fields that should exist in the parsed
- * URL object
- * @return {boolean}
+ * @param value - The string to be tested
+ * @param mandatoryFields - A list of mandatory fields that should exist in the parsed
+ * `URL` object
  */
-export function isUrl(value, ...mandatoryFields) {
+export function isUrl(value: string, ...mandatoryFields: (keyof URL)[]): boolean {
     try {
         const parsedUrl = new URL(value);
-        return mandatoryFields.every(f => parsedUrl[f]);
-    } catch (urlParsingError) {
+        return mandatoryFields.every((f) => parsedUrl[f]);
+    } catch {
         return false;
     }
 }
 
 /**
  * Checks if a given value is a function
- * @memberof core
- * @param {*} value - The value to check
- * @return {boolean}
+ * @param value - The value to check
  */
-export function isFunction(value) {
+export function isFunction(value: unknown): value is (...args: unknown[]) => unknown {
     return typeof value === 'function';
 }
 
 /**
  * Checks if a string matches any of the strings in a set of possibilities
- * @memberof core
- * @param {string} value
- * @param {string[]} possibilities - An array of strings that'll be used to check the string
+ * @param value
+ * @param possibilities - An array of strings that'll be used to check the string
  * inclusion. Note that for performance reasons, we don't validate this parameter.
- * @param {boolean} [caseSensitive=false] - Should the check be case sensitive
- * @return {boolean}
+ * @param caseSensitive - Should the check be case sensitive
  */
-export function isStrIn(value, possibilities, caseSensitive = false) {
-    const _isSameStrCaseInsensitive = str =>
+export function isStrIn(value: string, possibilities: string[], caseSensitive = false): boolean {
+    const _isSameStrCaseInsensitive = (str: string) =>
         isStr(str) && value.toUpperCase() === str.toUpperCase();
     if (!(isStr(value) && Array.isArray(possibilities))) {
         return false;

package/src/{version.js → version.ts}

@@ -1,5 +1,4 @@
 // Version is bumped automatically by release-please. See release-please-config.json.
 
-'use strict'
-const version = '5.2.7'; // x-release-please-version
+const version = '6.0.0-alpha.10'; // x-release-please-version
 export default version;