@intrig/react 0.0.15-28 → 0.0.15-29

package/media-type-utils.js

@@ -0,0 +1,127 @@
+import { XMLParser } from 'fast-xml-parser';
+
+// type Encoders = {
+//   [k: string]: <T>(
+//     request: T,
+//     mediaType: string,
+//     schema: ZodSchema,
+//   ) => Promise<any>;
+// };
+
+const encoders = {};
+function encode(request, mediaType, schema) {
+  if (encoders[mediaType]) {
+    return encoders[mediaType](request, mediaType, schema);
+  }
+  return request;
+}
+encoders['application/json'] = (request, mediaType, schema) => {
+  return request;
+};
+function appendFormData(formData, data, parentKey) {
+  if (data instanceof Blob || typeof data === 'string') {
+    formData.append(parentKey, data);
+  } else if (data !== null && typeof data === 'object') {
+    if (Array.isArray(data)) {
+      data.forEach((item, index) => {
+        const key = `${parentKey}`;
+        appendFormData(formData, item, key);
+      });
+    } else {
+      Object.keys(data).forEach(key => {
+        const newKey = parentKey ? `${parentKey}[${key}]` : key;
+        appendFormData(formData, data[key], newKey);
+      });
+    }
+  } else {
+    formData.append(parentKey, data == null ? '' : String(data));
+  }
+}
+encoders['multipart/form-data'] = (request, mediaType, schema) => {
+  const _request = request;
+  const formData = new FormData();
+  Object.keys(_request).forEach(key => {
+    appendFormData(formData, _request[key], key);
+  });
+  return formData;
+};
+encoders['application/octet-stream'] = (request, mediaType, schema) => {
+  return request;
+};
+encoders['application/x-www-form-urlencoded'] = (request, mediaType, schema) => {
+  const formData = new FormData();
+  for (const key in request) {
+    const value = request[key];
+    formData.append(key, value instanceof Blob || typeof value === 'string' ? value : String(value));
+  }
+  return formData;
+};
+const transformers = {};
+function transform(request, mediaType, schema) {
+  if (transformers[mediaType]) {
+    return transformers[mediaType](request, mediaType, schema);
+  }
+  throw new Error(`Unsupported media type: ` + mediaType);
+}
+transformers['application/json'] = async (request, mediaType, schema) => {
+  return schema.parse(await request.json());
+};
+transformers['multipart/form-data'] = async (request, mediaType, schema) => {
+  const formData = await request.formData();
+  const content = {};
+  formData.forEach((value, key) => {
+    if (content[key]) {
+      if (!(content[key] instanceof Array)) {
+        content[key] = [content[key]];
+      }
+      content[key].push(value);
+    } else {
+      content[key] = value;
+    }
+  });
+  return schema.parse(content);
+};
+transformers['application/octet-stream'] = async (request, mediaType, schema) => {
+  return schema.parse(new Blob([await request.arrayBuffer()], {
+    type: 'application/octet-stream'
+  }));
+};
+transformers['application/x-www-form-urlencoded'] = async (request, mediaType, schema) => {
+  const formData = await request.formData();
+  const content = {};
+  formData.forEach((value, key) => content[key] = value);
+  return schema.parse(content);
+};
+transformers['application/xml'] = async (request, mediaType, schema) => {
+  const xmlParser = new XMLParser();
+  const content = await xmlParser.parse(await request.text());
+  return schema.parse(await content);
+};
+transformers['text/plain'] = async (request, mediaType, schema) => {
+  return schema.parse(await request.text());
+};
+transformers['text/html'] = async (request, mediaType, schema) => {
+  return schema.parse(await request.text());
+};
+transformers['text/css'] = async (request, mediaType, schema) => {
+  return schema.parse(await request.text());
+};
+transformers['text/javascript'] = async (request, mediaType, schema) => {
+  return schema.parse(await request.text());
+};
+const responseTransformers = {};
+responseTransformers['application/json'] = async (data, mediaType, schema) => {
+  return schema.parse(data);
+};
+responseTransformers['application/xml'] = async (data, mediaType, schema) => {
+  const parsed = new XMLParser().parse(data);
+  return schema.parse(parsed);
+};
+async function transformResponse(data, mediaType, schema) {
+  if (responseTransformers[mediaType]) {
+    return await responseTransformers[mediaType](data, mediaType, schema);
+  }
+  return data;
+}
+
+export { encode, transform, transformResponse };

package/network-state.js

@@ -0,0 +1,353 @@
+/**
+ * State of an asynchronous call. Network state follows the state diagram given below.
+ *
+ *
+ * <pre>
+ *                 ┌──────┐
+ *   ┌─────────────► Init ◄────────────┐
+ *   │             └▲────┬┘            │
+ *   │              │    │             │
+ *   │           Reset  Execute        │
+ * Reset            │    │           Reset
+ *   │           ┌──┴────┴──┐          │
+ *   │      ┌────► Pending  ◄────┐     │
+ *   │      │    └──┬────┬──┘    │     │
+ *   │   Execute    │    │    Execute  │
+ *   │      │       │    │       │     │
+ *   │      │ OnSuccess OnError  │     │
+ *   │ ┌────┴──┐    │    │    ┌──┴───┐ │
+ *   └─┤Success◄────┘    └────►Error ├─┘
+ *     └───────┘              └──────┘
+ *
+ * </pre>
+ */
+
+/**
+ * Network call is not yet started
+ */
+
+/**
+ * Checks whether the state is init state
+ * @param state
+ */
+function isInit(state) {
+  return state.state === 'init';
+}
+
+/**
+ * Initializes a new state.
+ *
+ * @template T The type of the state.
+ * @return {InitState<T>} An object representing the initial state.
+ */
+function init() {
+  return {
+    state: 'init'
+  };
+}
+
+/**
+ * Network call is not yet completed
+ */
+
+/**
+ * Interface representing progress information for an upload or download operation.
+ *
+ * @typedef {object} Progress
+ *
+ * @property {'upload' | 'download'} type - The type of the operation.
+ *
+ * @property {number} loaded - The amount of data that has been loaded so far.
+ *
+ * @property {number} [total] - The total amount of data to be loaded (if known).
+ */
+
+/**
+ * Checks whether the state is pending state
+ * @param state
+ */
+function isPending(state) {
+  return state.state === 'pending';
+}
+
+/**
+ * Generates a PendingState object with a state of "pending".
+ *
+ * @return {PendingState<T>} An object representing the pending state.
+ */
+function pending(progress = undefined, data = undefined) {
+  return {
+    state: 'pending',
+    progress,
+    data
+  };
+}
+
+/**
+ * Network call is completed with success state
+ */
+
+/**
+ * Checks whether the state is success response
+ * @param state
+ */
+function isSuccess(state) {
+  return state.state === 'success';
+}
+
+/**
+ * Creates a success state object with the provided data.
+ *
+ * @param {T} data - The data to be included in the success state.
+ * @return {SuccessState<T>} An object representing a success state containing the provided data.
+ */
+function success(data) {
+  return {
+    state: 'success',
+    data
+  };
+}
+
+/**
+ * Network call is completed with error response
+ */
+
+/**
+ * Checks whether the state is error state
+ * @param state
+ */
+function isError(state) {
+  return state.state === 'error';
+}
+
+/**
+ * Constructs an ErrorState object representing an error.
+ *
+ * @param {any} error - The error object or message.
+ * @param {string} [statusCode] - An optional status code associated with the error.
+ * @return {ErrorState<T>} An object representing the error state.
+ */
+function error(error, statusCode, request) {
+  return {
+    state: 'error',
+    error,
+    statusCode,
+    request
+  };
+}
+
+/**
+ * Represents an error state with additional contextual information.
+ *
+ * @typedef {Object} ErrorWithContext
+ * @template T
+ * @extends ErrorState<T>
+ *
+ * @property {string} source - The origin of the error.
+ * @property {string} operation - The operation being performed when the error occurred.
+ * @property {string} key - A unique key identifying the specific error instance.
+ */
+
+/**
+ * Represents an action in the network context.
+ *
+ * @template T - The type of data associated with the network action
+ *
+ * @property {NetworkState<any>} state - The current state of the network action
+ * @property {string} key - The unique identifier for the network action
+ */
+
+/**
+ * Represents the dispatch state of a process.
+ *
+ * @template T The type of the state information.
+ * @interface
+ *
+ * @property {string} state The current state of the dispatch process.
+ */
+
+/**
+ * Represents a successful dispatch state.
+ *
+ * @template T - Type of the data associated with the dispatch.
+ *
+ * @extends DispatchState<T>
+ *
+ * @property {string} state - The state of the dispatch, always 'success'.
+ */
+
+/**
+ * Indicates a successful dispatch state.
+ *
+ * @return {DispatchState<T>} An object representing a successful state.
+ */
+function successfulDispatch() {
+  return {
+    state: 'success'
+  };
+}
+
+/**
+ * Determines if the provided dispatch state represents a successful dispatch.
+ *
+ * @param {DispatchState<T>} value - The dispatch state to check.
+ * @return {value is SuccessfulDispatch<T>} - True if the dispatch state indicates success, false otherwise.
+ */
+function isSuccessfulDispatch(value) {
+  return value.state === 'success';
+}
+
+/**
+ * ValidationError interface represents a specific type of dispatch state
+ * where a validation error has occurred.
+ *
+ * @typeparam T - The type of the data associated with this dispatch state.
+ */
+
+/**
+ * Generates a ValidationError object.
+ *
+ * @param error The error details that caused the validation to fail.
+ * @return The ValidationError object containing the error state and details.
+ */
+function validationError(error) {
+  return {
+    state: 'validation-error',
+    error
+  };
+}
+
+/**
+ * Determines if a provided DispatchState object is a ValidationError.
+ *
+ * @param {DispatchState<T>} value - The DispatchState object to evaluate.
+ * @return {boolean} - Returns true if the provided DispatchState object is a ValidationError, otherwise returns false.
+ */
+function isValidationError(value) {
+  return value.state === 'validation-error';
+}
+
+/**
+ * Represents an error structure with a specified type and associated data.
+ *
+ * @template T - The type of the data associated with the error.
+ * @template E - The type of the error detail.
+ *
+ * @property {string} type - A string representing the type of the error.
+ */
+
+/**
+ * Represents an error encountered during a network operation.
+ * Extends from the `IntrigError` interface, adding network-specific properties.
+ *
+ * @template T - The type of the intrinsic data associated with the error.
+ * @template E - The type of the error details, defaulting to `unknown`.
+ *
+ * @property {string} type - A constant property representing the error type, always set to 'network'.
+ * @property {string} statusCode - A string representation of the HTTP status code associated with the error, indicating the nature of the network failure.
+ * @property {E} error - The detailed error information specific to the failure, type extends from the generic E, allowing flexibility in the error details.
+ * @property {any} request - The request object that was attempted when the network error occurred, providing context for what operation failed.
+ */
+
+/**
+ * Constructs a network error object.
+ *
+ * @param error The error object corresponding to the network request.
+ * @param statusCode A string representing the HTTP status code returned.
+ * @param request The request object associated with the network operation.
+ * @return A NetworkError object containing the error type, status code, error details, and the original request.
+ */
+function networkError(error, statusCode, request) {
+  return {
+    type: 'network',
+    statusCode,
+    error,
+    request
+  };
+}
+
+/**
+ * Determines if the provided IntrigError is of type 'network'.
+ *
+ * @param {IntrigError<T, E>} value - The error value to check the type of.
+ * @return {boolean} - Returns true if the error is of type 'network', otherwise false.
+ */
+function isNetworkError(value) {
+  return value.type === 'network';
+}
+
+/**
+ * Interface representing a request validation error.
+ *
+ * This error occurs when a validation process on a request fails. It extends the IntrigError interface
+ * by adding specific properties related to request validation.
+ *
+ * @template T - The type of the data associated with the error.
+ * @template E - The optional type of additional error information. Defaults to unknown.
+ *
+ * @extends IntrigError<T, E>
+ *
+ * @property {string} type - A string literal indicating the error type as 'request-validation'.
+ * @property {ZodError} error - An instance of ZodError containing detailed validation error information.
+ */
+
+/**
+ * Constructs a RequestValidationError object encapsulating the ZodError.
+ *
+ * @param {ZodError} error - The error object resulting from Zod schema validation.
+ * @return {RequestValidationError<T, E>} A RequestValidationError object containing the validation error information.
+ */
+function requestValidationError(error) {
+  return {
+    type: 'request-validation',
+    error
+  };
+}
+
+/**
+ * Determines if a given error is of type RequestValidationError.
+ *
+ * @param value The error object to check, which implements the IntrigError interface.
+ * @return A boolean indicating whether the error is a RequestValidationError.
+ */
+function isRequestValidationError(value) {
+  return value.type === 'request-validation';
+}
+
+/**
+ * ResponseValidationError interface is designed to extend the capabilities of the IntrigError interface,
+ * specifically for handling errors related to response validation.
+ *
+ * @template T - Represents the type of the data or payload associated with the error.
+ * @template E - Represents the type of any additional error information. Defaults to unknown.
+ *
+ * @extends IntrigError
+ *
+ * @property type - A string literal that identifies the type of error as 'response-validation'.
+ * @property error - An instance of ZodError representing the validation error encountered.
+ */
+
+/**
+ * Constructs a ResponseValidationError object with a specified error.
+ *
+ * @param {ZodError} error - The validation error encountered during response validation.
+ * @return {ResponseValidationError<T, E>} An error object containing the type of error and the validation error details.
+ */
+function responseValidationError(error) {
+  return {
+    type: 'response-validation',
+    error
+  };
+}
+
+/**
+ * Determines if the given error is a response validation error.
+ *
+ * @param {IntrigError<T, E>} value - The error object to assess.
+ * @return {boolean} True if the error is a response validation error, otherwise false.
+ */
+function isResponseValidationError(value) {
+  return value.type === 'response-validation';
+}
+
+export { error, init, isError, isInit, isNetworkError, isPending, isRequestValidationError, isResponseValidationError, isSuccess, isSuccessfulDispatch, isValidationError, networkError, pending, requestValidationError, responseValidationError, success, successfulDispatch, validationError };

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@intrig/react",
-  "version": "0.0.15-28",
+  "version": "0.0.15-29",
   "type": "module",
-  "main": "./index.esm.js",
-  "module": "./index.esm.js",
-  "types": "./index.esm.d.ts",
+  "main": "./index.js",
+  "module": "./index.js",
+  "types": "./src/index.d.ts",
   "dependencies": {
     "axios": "^1.7.7",
     "date-fns": "^4.1.0",
@@ -12,7 +12,6 @@
     "fast-xml-parser": "^4.5.0",
     "immer": "^10.1.1",
     "loglevel": "1.8.1",
-    "module-alias": "^2.2.2",
     "zod": "^3.23.8"
   },
   "devDependencies": {
@@ -28,15 +27,24 @@
     "react": "^18.0.0 || ^19.0.0",
     "react-dom": "^18.0.0 || ^19.0.0"
   },
-  "_moduleAliases": {
-    "@intrig/react": "./src"
-  },
   "exports": {
     "./package.json": "./package.json",
     ".": {
-      "types": "./index.esm.d.ts",
-      "import": "./index.esm.js",
-      "default": "./index.esm.js"
+      "types": "./src/index.d.ts",
+      "import": "./index.js",
+      "default": "./index.js"
+    },
+    "./*": {
+      "types": "./src/*.d.ts",
+      "import": "./*.js",
+      "default": "./*.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "*": [
+        "src/*"
+      ]
     }
   }
 }