@hkdigital/lib-sveltekit 0.2.8 → 0.2.10

package/dist/util/http/index.js

@@ -1,22 +1,22 @@
-// import * as expect from '../expect/index.js';
-
-// import {
-// 	ResponseError,
-// 	AbortError,
-// 	TimeoutError,
-// 	TypeOrValueError
-// } from '$lib/constants/errors/index.js';
-
-// import { setRequestHeaders } from './headers.js';
-// import { getErrorFromResponse } from './errors.js';
-
-export * from './headers.js';
-export * from './errors.js';
-export * from './url.js';
-export * from './response.js';
-export * from './http-request.js';
-export * from './json-request.js';
-
-// import { CONTENT_TYPE, METHOD_GET, METHOD_POST } from '../../constants/http/index.js';
-
-// import { APPLICATION_JSON } from '../../constants/mime/index.js';
+// import * as expect from '../expect/index.js';
+
+// import {
+// 	ResponseError,
+// 	AbortError,
+// 	TimeoutError,
+// 	TypeOrValueError
+// } from '$lib/constants/errors/index.js';
+
+// import { setRequestHeaders } from './headers.js';
+// import { getErrorFromResponse } from './errors.js';
+
+export * from './headers.js';
+export * from './errors.js';
+export * from './url.js';
+export * from './response.js';
+export * from './http-request.js';
+export * from './json-request.js';
+
+// import { CONTENT_TYPE, METHOD_GET, METHOD_POST } from '../../constants/http/index.js';
+
+// import { APPLICATION_JSON } from '../../constants/mime/index.js';

package/dist/util/http/json-request.js

@@ -1,224 +1,224 @@
-import { METHOD_GET, METHOD_POST } from '../../constants/http/methods.js';
-
-import { APPLICATION_JSON } from '../../constants/mime/application.js';
-import { CONTENT_TYPE } from '../../constants/http/headers.js';
-import { ResponseError } from '../../constants/errors/index.js';
-
-import * as expect from '../expect/index.js';
-
-import { toURL } from './url.js';
-import { httpRequest } from './http-request.js';
-import { waitForAndCheckResponse } from './response.js';
-
-const ACCEPT = 'accept';
-
-/**
- * Make a GET request to fetch JSON encoded data
- *
- * This function performs a GET request and expects a JSON response from the server.
- * It handles common error cases and parses the JSON response.
- *
- * @param {import('./typedef').JsonGetOptions} options
- *   Request configuration options
- *
- * @returns {Promise<any>} Parsed JSON data
- *
- * @example
- * // Basic JSON GET request
- * try {
- *   const data = await jsonGet({
- *     url: 'https://api.example.com/users/123'
- *   });
- *   console.log(data); // { id: 123, name: "John Doe", ... }
- * } catch (error) {
- *   console.error('Failed to fetch user data:', error.message);
- * }
- *
- * @example
- * // JSON GET request with parameters
- * const data = await jsonGet({
- *   url: 'https://api.example.com/search',
- *   urlSearchParams: new URLSearchParams({ q: 'search term' }),
- *   withCredentials: true
- * });
- *
- * @example
- * // Using advanced options
- * const data = await jsonGet({
- *   url: 'https://api.example.com/data',
- *   timeoutMs: 5000,
- *   requestHandler: ({ abort }) => {
- *     // Store abort function
- *     window.abortDataRequest = abort;
- *   }
- * });
- */
-export async function jsonGet(options) {
-  // Extract specific parameters needed for this function
-  const {
-    url: rawUrl,
-    urlSearchParams,
-    headers,
-    withCredentials,
-    ...otherOptions
-  } = options;
-
-  const url = toURL(rawUrl);
-
-  // Apply JSON-specific defaults
-  const jsonHeaders = headers || {};
-  jsonHeaders[ACCEPT] = APPLICATION_JSON;
-
-  // Create request with all options
-  const responsePromise = httpRequest({
-    method: METHOD_GET,
-    url,
-    urlSearchParams,
-    headers: jsonHeaders,
-    withCredentials,
-    ...otherOptions // Pass through any other options
-  });
-
-  const response = await waitForAndCheckResponse(responsePromise, url);
-
-  let parsedResponse;
-
-  try {
-    //
-    // @note when security on the client side fails, an `opaque` response
-    //       is returned by the browser (empty body) -> parsing fails
-    //       (use CORS to fix this)
-    //
-    parsedResponse = await response.json();
-  } catch (e) {
-    throw new ResponseError(
-      `Failed to JSON decode server response from [${decodeURI(url.href)}]`,
-      {
-        cause: e
-      }
-    );
-  }
-
-  if (parsedResponse.error) {
-    throw new ResponseError(
-      `Server returned response error message [${parsedResponse.error}]`
-    );
-  }
-
-  return parsedResponse;
-}
-
-/**
- * Make a POST request to fetch JSON encoded data
- *
- * This function performs a POST request with JSON data and expects a JSON
- * response from the server. It handles common error cases and parses the JSON response.
- *
- * @param {import('./typedef').JsonPostOptions} options
- *   Request configuration options
- *
- * @returns {Promise<any>} Parsed JSON data
- *
- * @example
- * // Basic JSON POST request
- * try {
- *   const newUser = {
- *     name: "Jane Smith",
- *     email: "jane@example.com"
- *   };
- *
- *   const data = await jsonPost({
- *     url: 'https://api.example.com/users',
- *     body: JSON.stringify(newUser)
- *   });
- *
- *   console.log('Created user with ID:', data.id);
- * } catch (error) {
- *   console.error('Failed to create user:', error.message);
- * }
- *
- * @example
- * // JSON POST with authentication and timeout
- * const data = await jsonPost({
- *   url: 'https://api.example.com/protected/resource',
- *   body: JSON.stringify({ action: 'update' }),
- *   headers: {
- *     'authorization': 'Bearer ' + token
- *   },
- *   withCredentials: true,
- *   timeoutMs: 5000
- * });
- */
-export async function jsonPost(options) {
-  // Extract specific parameters needed for this function
-  const {
-    url: rawUrl,
-    body,
-    urlSearchParams,
-    headers,
-    withCredentials,
-    ...otherOptions
-  } = options;
-
-  const url = toURL(rawUrl);
-
-  // Apply JSON-specific defaults and validation
-  expect.defined(body);
-
-  const jsonHeaders = headers || {};
-  jsonHeaders[ACCEPT] = APPLICATION_JSON;
-  jsonHeaders[CONTENT_TYPE] = APPLICATION_JSON;
-
-  // Check if body is a string when using application/json
-  if (
-    jsonHeaders[CONTENT_TYPE] === APPLICATION_JSON &&
-    typeof body !== 'string'
-  ) {
-    throw new Error(
-      `Trying to send request with [content-type:${APPLICATION_JSON}], ` +
-        'but body is not a (JSON encoded) string.'
-    );
-  }
-
-  // Create request with all options
-  const responsePromise = httpRequest({
-    method: METHOD_POST,
-    url,
-    body,
-    urlSearchParams,
-    headers: jsonHeaders,
-    withCredentials,
-    ...otherOptions // Pass through any other options
-  });
-
-  const response = await waitForAndCheckResponse(responsePromise, url);
-
-  let parsedResponse;
-
-  try {
-    //
-    // @note when security on the client side fails, an `opaque` response
-    //       is returned by the browser (empty body) -> parsing fails
-    //       (use CORS to fix this)
-    //
-    parsedResponse = await response.json();
-  } catch (e) {
-    throw new ResponseError(
-      `Failed to JSON decode server response from [${decodeURI(url.href)}]`,
-      {
-        cause: e
-      }
-    );
-  }
-
-  if (parsedResponse.error) {
-    //
-    // @note this is API specific, but it's quite logical
-    //
-    throw new ResponseError(
-      `Server returned response error message [${parsedResponse.error}]`
-    );
-  }
-
-  return parsedResponse;
-}
+import { METHOD_GET, METHOD_POST } from '../../constants/http/methods.js';
+
+import { APPLICATION_JSON } from '../../constants/mime/application.js';
+import { CONTENT_TYPE } from '../../constants/http/headers.js';
+import { ResponseError } from '../../constants/errors/index.js';
+
+import * as expect from '../expect/index.js';
+
+import { toURL } from './url.js';
+import { httpRequest } from './http-request.js';
+import { waitForAndCheckResponse } from './response.js';
+
+const ACCEPT = 'accept';
+
+/**
+ * Make a GET request to fetch JSON encoded data
+ *
+ * This function performs a GET request and expects a JSON response from the server.
+ * It handles common error cases and parses the JSON response.
+ *
+ * @param {import('./typedef').JsonGetOptions} options
+ *   Request configuration options
+ *
+ * @returns {Promise<any>} Parsed JSON data
+ *
+ * @example
+ * // Basic JSON GET request
+ * try {
+ *   const data = await jsonGet({
+ *     url: 'https://api.example.com/users/123'
+ *   });
+ *   console.log(data); // { id: 123, name: "John Doe", ... }
+ * } catch (error) {
+ *   console.error('Failed to fetch user data:', error.message);
+ * }
+ *
+ * @example
+ * // JSON GET request with parameters
+ * const data = await jsonGet({
+ *   url: 'https://api.example.com/search',
+ *   urlSearchParams: new URLSearchParams({ q: 'search term' }),
+ *   withCredentials: true
+ * });
+ *
+ * @example
+ * // Using advanced options
+ * const data = await jsonGet({
+ *   url: 'https://api.example.com/data',
+ *   timeoutMs: 5000,
+ *   requestHandler: ({ abort }) => {
+ *     // Store abort function
+ *     window.abortDataRequest = abort;
+ *   }
+ * });
+ */
+export async function jsonGet(options) {
+  // Extract specific parameters needed for this function
+  const {
+    url: rawUrl,
+    urlSearchParams,
+    headers,
+    withCredentials,
+    ...otherOptions
+  } = options;
+
+  const url = toURL(rawUrl);
+
+  // Apply JSON-specific defaults
+  const jsonHeaders = headers || {};
+  jsonHeaders[ACCEPT] = APPLICATION_JSON;
+
+  // Create request with all options
+  const responsePromise = httpRequest({
+    method: METHOD_GET,
+    url,
+    urlSearchParams,
+    headers: jsonHeaders,
+    withCredentials,
+    ...otherOptions // Pass through any other options
+  });
+
+  const response = await waitForAndCheckResponse(responsePromise, url);
+
+  let parsedResponse;
+
+  try {
+    //
+    // @note when security on the client side fails, an `opaque` response
+    //       is returned by the browser (empty body) -> parsing fails
+    //       (use CORS to fix this)
+    //
+    parsedResponse = await response.json();
+  } catch (e) {
+    throw new ResponseError(
+      `Failed to JSON decode server response from [${decodeURI(url.href)}]`,
+      {
+        cause: e
+      }
+    );
+  }
+
+  if (parsedResponse.error) {
+    throw new ResponseError(
+      `Server returned response error message [${parsedResponse.error}]`
+    );
+  }
+
+  return parsedResponse;
+}
+
+/**
+ * Make a POST request to fetch JSON encoded data
+ *
+ * This function performs a POST request with JSON data and expects a JSON
+ * response from the server. It handles common error cases and parses the JSON response.
+ *
+ * @param {import('./typedef').JsonPostOptions} options
+ *   Request configuration options
+ *
+ * @returns {Promise<any>} Parsed JSON data
+ *
+ * @example
+ * // Basic JSON POST request
+ * try {
+ *   const newUser = {
+ *     name: "Jane Smith",
+ *     email: "jane@example.com"
+ *   };
+ *
+ *   const data = await jsonPost({
+ *     url: 'https://api.example.com/users',
+ *     body: JSON.stringify(newUser)
+ *   });
+ *
+ *   console.log('Created user with ID:', data.id);
+ * } catch (error) {
+ *   console.error('Failed to create user:', error.message);
+ * }
+ *
+ * @example
+ * // JSON POST with authentication and timeout
+ * const data = await jsonPost({
+ *   url: 'https://api.example.com/protected/resource',
+ *   body: JSON.stringify({ action: 'update' }),
+ *   headers: {
+ *     'authorization': 'Bearer ' + token
+ *   },
+ *   withCredentials: true,
+ *   timeoutMs: 5000
+ * });
+ */
+export async function jsonPost(options) {
+  // Extract specific parameters needed for this function
+  const {
+    url: rawUrl,
+    body,
+    urlSearchParams,
+    headers,
+    withCredentials,
+    ...otherOptions
+  } = options;
+
+  const url = toURL(rawUrl);
+
+  // Apply JSON-specific defaults and validation
+  expect.defined(body);
+
+  const jsonHeaders = headers || {};
+  jsonHeaders[ACCEPT] = APPLICATION_JSON;
+  jsonHeaders[CONTENT_TYPE] = APPLICATION_JSON;
+
+  // Check if body is a string when using application/json
+  if (
+    jsonHeaders[CONTENT_TYPE] === APPLICATION_JSON &&
+    typeof body !== 'string'
+  ) {
+    throw new Error(
+      `Trying to send request with [content-type:${APPLICATION_JSON}], ` +
+        'but body is not a (JSON encoded) string.'
+    );
+  }
+
+  // Create request with all options
+  const responsePromise = httpRequest({
+    method: METHOD_POST,
+    url,
+    body,
+    urlSearchParams,
+    headers: jsonHeaders,
+    withCredentials,
+    ...otherOptions // Pass through any other options
+  });
+
+  const response = await waitForAndCheckResponse(responsePromise, url);
+
+  let parsedResponse;
+
+  try {
+    //
+    // @note when security on the client side fails, an `opaque` response
+    //       is returned by the browser (empty body) -> parsing fails
+    //       (use CORS to fix this)
+    //
+    parsedResponse = await response.json();
+  } catch (e) {
+    throw new ResponseError(
+      `Failed to JSON decode server response from [${decodeURI(url.href)}]`,
+      {
+        cause: e
+      }
+    );
+  }
+
+  if (parsedResponse.error) {
+    //
+    // @note this is API specific, but it's quite logical
+    //
+    throw new ResponseError(
+      `Server returned response error message [${parsedResponse.error}]`
+    );
+  }
+
+  return parsedResponse;
+}

package/dist/util/http/mocks.js

@@ -1,65 +1,65 @@
-import { CONTENT_TYPE, CONTENT_LENGTH } from '../../constants/http/index.js';
-
-import { OCTET_STREAM } from '../../constants/mime/index.js';
-
-/**
- * Create a response value that can be used by a mocked fetch function
- *
- * @template T
- *
- * @param {T} data
- *
- * @returns {{ json: () => Promise<T>}}
- */
-export function createJsonFetchResponse(data /* , options */) {
-	return { json: () => new Promise((resolve) => resolve(data)) };
-}
-
-/**
- * Create a response value that can be used by a mocked fetch function
- *
- * @param {ArrayBuffer} arrayBuffer
- *
- * @returns {Response}
- */
-export function createStreamedResponse(arrayBuffer /*, options */) {
-	const byteLength = arrayBuffer.byteLength;
-	const chunkSize = Math.ceil(byteLength / 10);
-
-	const body = new ReadableStream({
-		start(controller) {
-			let offset = 0;
-
-			function pushChunk() {
-				if (offset >= byteLength) {
-					controller.close();
-					return;
-				}
-
-				// Calculate the size of the current chunk
-				const currentChunkSize = Math.min(chunkSize, byteLength - offset);
-
-				// Create a new ArrayBuffer for this chunk
-				const chunk = arrayBuffer.slice(offset, offset + currentChunkSize);
-
-				controller.enqueue(chunk);
-				offset += currentChunkSize;
-
-				// Schedule next chunk
-				setTimeout(pushChunk, 0);
-			}
-
-			// Start pushing chunks
-			pushChunk();
-		}
-	});
-
-	const response = new Response(body, {
-		headers: new Headers({
-			[CONTENT_TYPE]: OCTET_STREAM,
-			[CONTENT_LENGTH]: String(byteLength)
-		})
-	});
-
-	return response;
-}
+import { CONTENT_TYPE, CONTENT_LENGTH } from '../../constants/http/index.js';
+
+import { OCTET_STREAM } from '../../constants/mime/index.js';
+
+/**
+ * Create a response value that can be used by a mocked fetch function
+ *
+ * @template T
+ *
+ * @param {T} data
+ *
+ * @returns {{ json: () => Promise<T>}}
+ */
+export function createJsonFetchResponse(data /* , options */) {
+	return { json: () => new Promise((resolve) => resolve(data)) };
+}
+
+/**
+ * Create a response value that can be used by a mocked fetch function
+ *
+ * @param {ArrayBuffer} arrayBuffer
+ *
+ * @returns {Response}
+ */
+export function createStreamedResponse(arrayBuffer /*, options */) {
+	const byteLength = arrayBuffer.byteLength;
+	const chunkSize = Math.ceil(byteLength / 10);
+
+	const body = new ReadableStream({
+		start(controller) {
+			let offset = 0;
+
+			function pushChunk() {
+				if (offset >= byteLength) {
+					controller.close();
+					return;
+				}
+
+				// Calculate the size of the current chunk
+				const currentChunkSize = Math.min(chunkSize, byteLength - offset);
+
+				// Create a new ArrayBuffer for this chunk
+				const chunk = arrayBuffer.slice(offset, offset + currentChunkSize);
+
+				controller.enqueue(chunk);
+				offset += currentChunkSize;
+
+				// Schedule next chunk
+				setTimeout(pushChunk, 0);
+			}
+
+			// Start pushing chunks
+			pushChunk();
+		}
+	});
+
+	const response = new Response(body, {
+		headers: new Headers({
+			[CONTENT_TYPE]: OCTET_STREAM,
+			[CONTENT_LENGTH]: String(byteLength)
+		})
+	});
+
+	return response;
+}