@xy-planning-network/trees 0.6.2-rc-7 → 0.6.2-rc-8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xy-planning-network/trees",
-  "version": "0.6.2-rc-7",
+  "version": "0.6.2-rc-8",
   "description": "",
   "license": "MIT",
   "repository": "github:xy-planning-network/trees",

package/src/lib-components/lists/Table.vue

@@ -11,7 +11,7 @@ import Paginator from "../navigation/Paginator.vue"
 import BaseAPI from "../../api/base"
 import * as TableTypes from "@/composables/table"
 import { useAppFlasher } from "@/composables/useFlashes"
-import { TrailsResponsePaged } from "@/api/client"
+import { TrailsRespPaged } from "@/api/client"
 
 const props = withDefaults(
   defineProps<{
@@ -96,7 +96,7 @@ const loadAndRender = (): void => {
     q: query.value,
   }
 
-  BaseAPI.get<TrailsResponsePaged<unknown>>(
+  BaseAPI.get<TrailsRespPaged<unknown>>(
     props.tableData.url,
     { skipLoader: !props.loader },
     params

package/types/api/base.d.ts

@@ -1,16 +1,8 @@
 import { AxiosRequestConfig } from "axios";
-import { HttpClient, HttpError, HttpPromise, RequestOptions } from "./client";
-export declare const httpRequest: <T = any>(config: AxiosRequestConfig, opts: RequestOptions) => HttpPromise<T>;
+import { HttpClient, HttpError, HttpPromise, ReqOptions } from "./client";
+export declare const httpRequest: <T = any>(config: AxiosRequestConfig, opts: ReqOptions) => HttpPromise<T>;
 declare const BaseAPI: HttpClient;
 export default BaseAPI;
-/**
- * A convenience method for checking if a variable in a failed request has an http status code.
- * This is most useful for checking for specific http status codes in error callbacks.
- * @param err unknown
- * @param codes number | number[]
- * @returns boolean
- */
-export declare const hasHttpErrStatus: (err: unknown, codes: number | number[]) => boolean;
 /**
  * A type guard for checking if a variable is in the shape of a HttpError
  * @param err unknown

package/types/api/client.d.ts

@@ -1,13 +1,13 @@
 /**
- * RequestMethod
+ * ReqMethod
  * The HTTP request methods that our http client supports.
  */
-export declare type RequestMethod = "GET" | "get" | "PATCH" | "patch" | "PUT" | "put" | "POST" | "post" | "DELETE" | "delete";
+export declare type ReqMethod = "DELETE" | "delete" | "GET" | "get" | "PATCH" | "patch" | "POST" | "post" | "PUT" | "put";
 /**
- * RequestOptions
+ * ReqOptions
  * The set of options available for any http client request.
  */
-export interface RequestOptions {
+export interface ReqOptions {
     /**
      * Disable the full screen loading interface during the request when true.
      */
@@ -17,21 +17,21 @@ export interface RequestOptions {
      */
     withDelay?: number;
 }
-export declare const HTTP_ERROR = "HttpError";
-export declare const HTTP_CANCELLED_ERROR = "HttpCanceledError";
+export declare const HTTP_ERR = "HttpError";
+export declare const HTTP_ERR_CANCEL = "HttpErrorCanceled";
 /**
  * HttpError
  * An http client error when the request is rejected.
  */
 export declare class HttpError<T = unknown> extends Error {
-    /**
-     * The http response status code.
-     */
-    status: number;
     /**
      * The http response body.
      */
     response?: T;
+    /**
+     * The http response status code.
+     */
+    status: number;
     constructor(message?: string, status?: number, response?: T, name?: string);
 }
 /**
@@ -44,16 +44,16 @@ export interface HttpPromise<T = any> extends Promise<T> {
  * TrailsPromise
  * The successfully resolved interface of an http client request returned by @xy-planning-network/Trails.
  */
-export interface TrailsPromise<T = any> extends Promise<TrailsResponse<T>> {
+export interface TrailsPromise<T = any> extends Promise<TrailsResp<T>> {
 }
 /**
  * TrailsPromisePaged
  * The successfully resolved interface of a paged http client request returned by @xy-planning-network/Trails.
  */
-export interface TrailsPromisePaged<T = any> extends Promise<TrailsResponsePaged<T>> {
+export interface TrailsPromisePaged<T = any> extends Promise<TrailsRespPaged<T>> {
 }
 /**
- * TrailsResponse
+ * TrailsResp
  * A convenience interface to represent the shape of a Trails delivered API response.
  *
  * Example Usage:
@@ -62,18 +62,18 @@ export interface TrailsPromisePaged<T = any> extends Promise<TrailsResponsePaged
  *     email: string
  * }
  *
- * BaseAPI.get<TrailsResponse<User>>(`/user/${id}`)
- *     .then(result => {
+ * BaseAPI.get<TrailsResp<User>>(`/user/${id}`)
+ *     .then((result) => {
  *         const id = result.data.id
  *         const email = result.data.email
- *         const user = { ...result.data }
+ *         const user = result.data
  *     })
  */
-export interface TrailsResponse<T = any> {
+export interface TrailsResp<T = any> {
     data: T;
 }
 /**
- * TrailsResponsePaged
+ * TrailsRespPaged
  * A convenience interface to represent the shape of a paginated Trails delivered API response.
  *
  * Example Usage:
@@ -82,17 +82,17 @@ export interface TrailsResponse<T = any> {
  *     email: string
  * }
  *
- * BaseAPI.get<TrailsResponsePaged<User>>(`/users`)
- *     .then(result => {
+ * BaseAPI.get<TrailsRespPaged<User>>(`/users`)
+ *     .then((result) => {
  *         const currentPage = result.data.page
- *         const users = { ...result.data.items }
+ *         const users = result.data.items
  *
- *         result.data.items.forEach(u => {
+ *         users.forEach((u) => {
  *             console.log(u.id)
  *         })
  *     })
  */
-export interface TrailsResponsePaged<T = any> {
+export interface TrailsRespPaged<T = any> {
     data: {
         items: T[];
         page: number;
@@ -107,49 +107,49 @@ export interface TrailsResponsePaged<T = any> {
  */
 export declare type QueryParams = Record<string, any>;
 /**
- * RequestPayload
+ * ReqPayload
  * Http POST and PUT payloads.
  */
-export declare type RequestPayload = Record<string, any> | FormData;
+export declare type ReqPayload = Record<string, any> | FormData;
 /**
  * HttpClient
  * The http client interface the BaseAPI implements.
  */
 export interface HttpClient {
     /**
-     * The method to make an http GET request.
+     * The method to make an http DELETE request.
      * @param path string
-     * @param opts RequestOptions
-     * @param params QueryParams
+     * @param opts ReqOptions
      * @returns HttpPromise<T>
      */
-    get<T>(path: string, opts?: RequestOptions, params?: QueryParams): HttpPromise<T>;
+    delete<T>(path: string, opts?: ReqOptions): HttpPromise<T>;
     /**
-     * The method to make an http DELETE request.
+     * The method to make an http GET request.
      * @param path string
-     * @param opts RequestOptions
+     * @param opts ReqOptions
+     * @param params QueryParams
      * @returns HttpPromise<T>
      */
-    delete<T>(path: string, opts?: RequestOptions): HttpPromise<T>;
+    get<T>(path: string, opts?: ReqOptions, params?: QueryParams): HttpPromise<T>;
     /**
      * The method to make an http PATCH request.
      * @param path string
-     * @param data RequestPayload
-     * @param opts RequestOptions
+     * @param data ReqPayload
+     * @param opts ReqOptions
      */
-    patch<T>(path: string, data?: RequestPayload, opts?: RequestOptions): HttpPromise<T>;
+    patch<T>(path: string, data?: ReqPayload, opts?: ReqOptions): HttpPromise<T>;
     /**
      * The method to make an http POST request.
      * @param path string
-     * @param data RequestPayload
-     * @param opts RequestOptions
+     * @param data ReqPayload
+     * @param opts ReqOptions
      */
-    post<T>(path: string, data?: RequestPayload, opts?: RequestOptions): HttpPromise<T>;
+    post<T>(path: string, data?: ReqPayload, opts?: ReqOptions): HttpPromise<T>;
     /**
      * The method to make an http PUT request.
      * @param path string
-     * @param data RequestPayload
-     * @param opts RequestOptions
+     * @param data ReqPayload
+     * @param opts ReqOptions
      */
-    put<T>(path: string, data?: RequestPayload, opts?: RequestOptions): HttpPromise<T>;
+    put<T>(path: string, data?: ReqPayload, opts?: ReqOptions): HttpPromise<T>;
 }

package/types/composables/useBaseAPI.d.ts

@@ -1,11 +1,11 @@
 import { Ref, ShallowRef } from "vue";
-import type { HttpPromise, HttpError, RequestMethod, RequestOptions, RequestPayload } from "../api/client";
+import type { HttpPromise, HttpError, ReqMethod, ReqOptions, ReqPayload } from "../api/client";
 /**
- * UseBaseAPIOptions extends Trees/RequestOptions
+ * UseBaseAPIOptions extends Trees/ReqOptions
  * these options are used only in the instantiation
  * of a new UseBaseAPI composable
  */
-export interface UseBaseAPIOptions extends RequestOptions {
+export interface UseBaseAPIOptions extends ReqOptions {
     /**
      * Whether to immediately fire the execute function during instantiation
      */
@@ -50,17 +50,17 @@ export interface UseBaseAPI<T> {
      * Manually call the axios request
      * can be used multiple times
      */
-    execute: (data?: RequestPayload, opts?: RequestOptions) => HttpPromise<T>;
+    execute: (data?: ReqPayload, opts?: ReqOptions) => HttpPromise<T>;
 }
 /**
  * useBaseAPI is a composable wrapper of BaseAPI
  * @param path {string} the api path or full url for the
- * @param method {RequestMethod} the initial request type
+ * @param method {ReqMethod} the initial request type
  * @param initOpts {UseBaseAPIOptions}
  * @param initConfig {AxiosRequestConfig}
  * @returns {UseBaseAPI<T>}
  */
-export default function useBaseAPI<T = any>(path: string, method?: RequestMethod, initOpts?: UseBaseAPIOptions): UseBaseAPI<T>;
+export default function useBaseAPI<T = any>(path: string, method?: ReqMethod, initOpts?: UseBaseAPIOptions): UseBaseAPI<T>;
 /**
  * useBaseAPIGet is a convenience function for useBaseAPI
  * @param path {string} the api path or full url for the

package/types/entry.d.ts

@@ -1,9 +1,9 @@
 import { Plugin } from "vue";
-import BaseAPI, { hasHttpErrStatus, isHttpCancel, isHttpError } from "./api/base";
-import type { HttpPromise, HttpError, QueryParams, RequestOptions, RequestPayload, TrailsPromise, TrailsPromisePaged, TrailsResponse, TrailsResponsePaged } from "./api/client";
+import BaseAPI, { isHttpCancel, isHttpError } from "./api/base";
+import type { HttpPromise, HttpError, QueryParams, ReqOptions, ReqPayload, TrailsPromise, TrailsPromisePaged, TrailsResp, TrailsRespPaged } from "./api/client";
 declare const install: Exclude<Plugin["install"], undefined>;
 export default install;
 export * from "./composables/index";
 export * from "./lib-components/index";
-export { BaseAPI, hasHttpErrStatus, isHttpCancel, isHttpError };
-export type { HttpPromise, HttpError, QueryParams, RequestOptions, RequestPayload, TrailsPromise, TrailsPromisePaged, TrailsResponse, TrailsResponsePaged, };
+export { BaseAPI, isHttpCancel, isHttpError };
+export type { HttpPromise, HttpError, QueryParams, ReqOptions, ReqPayload, TrailsPromise, TrailsPromisePaged, TrailsResp, TrailsRespPaged, };