chore(release): v1.1.0

CHANGELOG.md

@@ -0,0 +1,8 @@
+# Changelog
+
+# 1.1.0 (2023-05-14)
+
+
+### Features
+
+* initial Klient instance ([ba74c1d](https://github.com/klientjs/core/commit/ba74c1d4b8c0c46468d22c55fcfda79404f19629))

dist/cjs/events/debug.d.ts

@@ -0,0 +1,10 @@
+import Event from './event';
+import type Listener from '../services/dispatcher/listener';
+export default class DebugEvent extends Event {
+    action: string;
+    relatedEvent: Event;
+    handler: Listener<never> | Listener<never>[];
+    error: Error | null;
+    static NAME: string;
+    constructor(action: string, relatedEvent: Event, handler: Listener<never> | Listener<never>[], error: Error | null);
+}

dist/cjs/events/debug.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const event_1 = require("./event");
+class DebugEvent extends event_1.default {
+    constructor(action, relatedEvent, handler, error) {
+        super();
+        this.action = action;
+        this.relatedEvent = relatedEvent;
+        this.handler = handler;
+        this.error = error;
+    }
+}
+exports.default = DebugEvent;
+DebugEvent.NAME = 'debug';

dist/cjs/events/event.d.ts

@@ -0,0 +1,11 @@
+export default class Event {
+    static NAME: string;
+    readonly dispatch: {
+        propagation: boolean;
+        skipNextListeners: number;
+        skipUntilListener?: number;
+    };
+    stopPropagation(): void;
+    skipNextListeners(total: number): void;
+    skipUntilListener(id: number): void;
+}

dist/cjs/events/event.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Event {
+    constructor() {
+        this.dispatch = {
+            propagation: true,
+            skipNextListeners: 0,
+            skipUntilListener: undefined
+        };
+    }
+    stopPropagation() {
+        this.dispatch.propagation = false;
+    }
+    skipNextListeners(total) {
+        this.dispatch.skipNextListeners = total;
+    }
+    skipUntilListener(id) {
+        this.dispatch.skipUntilListener = id;
+    }
+}
+exports.default = Event;
+Event.NAME = 'event';

dist/cjs/events/request/cancel.d.ts

@@ -0,0 +1,6 @@
+import RequestEvent from './request';
+export default class RequestCancelEvent<T = unknown> extends RequestEvent {
+    relatedEvent: RequestEvent<T>;
+    static NAME: string;
+    constructor(relatedEvent: RequestEvent<T>);
+}

dist/cjs/events/request/cancel.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const request_1 = require("./request");
+class RequestCancelEvent extends request_1.default {
+    constructor(relatedEvent) {
+        super(relatedEvent.request);
+        this.relatedEvent = relatedEvent;
+    }
+}
+exports.default = RequestCancelEvent;
+RequestCancelEvent.NAME = 'request:cancel';

dist/cjs/events/request/done.d.ts

@@ -0,0 +1,11 @@
+import RequestEvent from './request';
+import RequestSuccessEvent from './success';
+import type RequestErrorEvent from './error';
+export default class RequestDoneEvent<T = unknown> extends RequestEvent {
+    relatedEvent: RequestSuccessEvent<T> | RequestErrorEvent<T>;
+    static NAME: string;
+    constructor(relatedEvent: RequestSuccessEvent<T> | RequestErrorEvent<T>);
+    get success(): boolean;
+    get result(): import("axios").AxiosResponse<any, any> | import("axios").AxiosError<unknown, any> | undefined;
+    get data(): unknown;
+}

dist/cjs/events/request/done.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const request_1 = require("./request");
+const success_1 = require("./success");
+class RequestDoneEvent extends request_1.default {
+    constructor(relatedEvent) {
+        super(relatedEvent.request);
+        this.relatedEvent = relatedEvent;
+    }
+    get success() {
+        return this.relatedEvent instanceof success_1.default;
+    }
+    get result() {
+        return this.request.result;
+    }
+    get data() {
+        return this.relatedEvent.data;
+    }
+}
+exports.default = RequestDoneEvent;
+RequestDoneEvent.NAME = 'request:done';

dist/cjs/events/request/error.d.ts

@@ -0,0 +1,10 @@
+import type { AxiosError } from 'axios';
+import RequestEvent from './request';
+export default class RequestErrorEvent<T = unknown> extends RequestEvent<T> {
+    relatedEvent: RequestEvent<T>;
+    static NAME: string;
+    constructor(relatedEvent: RequestEvent<T>);
+    get error(): AxiosError;
+    get response(): import("axios").AxiosResponse<unknown, any> | undefined;
+    get data(): unknown;
+}

dist/cjs/events/request/error.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const request_1 = require("./request");
+class RequestErrorEvent extends request_1.default {
+    constructor(relatedEvent) {
+        super(relatedEvent.request);
+        this.relatedEvent = relatedEvent;
+    }
+    get error() {
+        return this.request.result;
+    }
+    get response() {
+        return this.error.response;
+    }
+    get data() {
+        var _a;
+        return (_a = this.response) === null || _a === void 0 ? void 0 : _a.data;
+    }
+}
+exports.default = RequestErrorEvent;
+RequestErrorEvent.NAME = 'request:error';

dist/cjs/events/request/request.d.ts

@@ -0,0 +1,12 @@
+import Event from '../event';
+import type Request from '../../services/request/request';
+import type { KlientRequestConfig } from '../../services/request/request';
+export default class RequestEvent<T = unknown> extends Event {
+    request: Request<T>;
+    static NAME: string;
+    constructor(request: Request<T>);
+    get config(): KlientRequestConfig;
+    get context(): {
+        [x: string]: any;
+    };
+}

dist/cjs/events/request/request.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const event_1 = require("../event");
+class RequestEvent extends event_1.default {
+    constructor(request) {
+        super();
+        this.request = request;
+    }
+    get config() {
+        return this.request.config;
+    }
+    get context() {
+        return this.request.context;
+    }
+}
+exports.default = RequestEvent;
+RequestEvent.NAME = 'request';

dist/cjs/events/request/success.d.ts

@@ -0,0 +1,9 @@
+import type { AxiosResponse } from 'axios';
+import RequestEvent from './request';
+export default class RequestSuccessEvent<T = unknown> extends RequestEvent {
+    relatedEvent: RequestEvent<T>;
+    static NAME: string;
+    constructor(relatedEvent: RequestEvent<T>);
+    get response(): AxiosResponse<T>;
+    get data(): T;
+}

dist/cjs/events/request/success.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const request_1 = require("./request");
+class RequestSuccessEvent extends request_1.default {
+    constructor(relatedEvent) {
+        super(relatedEvent.request);
+        this.relatedEvent = relatedEvent;
+    }
+    get response() {
+        return this.request.result;
+    }
+    get data() {
+        return this.response.data;
+    }
+}
+exports.default = RequestSuccessEvent;
+RequestSuccessEvent.NAME = 'request:success';

dist/cjs/extensions.d.ts

@@ -0,0 +1,10 @@
+import type Klient from '.';
+export declare type Extension = {
+    name: string;
+    initialize: (klient: Klient) => void;
+};
+declare class Extensions extends Array<Extension> {
+    load(klient: Klient, extensions?: string[]): void;
+}
+declare const _default: Extensions;
+export default _default;

dist/cjs/extensions.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Extensions extends Array {
+    load(klient, extensions) {
+        for (let i = 0, len = this.length; i < len; i += 1) {
+            const { name, initialize } = this[i];
+            if (!klient.extensions.includes(name) && (!extensions || extensions.includes(name))) {
+                initialize(klient);
+                klient.extensions.push(name);
+            }
+        }
+    }
+}
+exports.default = new Extensions();

dist/cjs/index.d.ts

@@ -0,0 +1,15 @@
+import Klient from './klient';
+export { default as Extensions } from './extensions';
+export { default as Bag } from './services/bag';
+export { default as Dispatcher } from './services/dispatcher/dispatcher';
+export { default as RequestFactory } from './services/request/factory';
+export { default as Request } from './services/request/request';
+export { default as Event } from './events/event';
+export { default as RequestEvent } from './events/request/request';
+export { default as RequestSuccessEvent } from './events/request/success';
+export { default as RequestErrorEvent } from './events/request/error';
+export { default as RequestCancelEvent } from './events/request/cancel';
+export { default as RequestDoneEvent } from './events/request/done';
+export type { Parameters } from './parameters';
+export type { KlientRequestConfig } from './services/request/request';
+export default Klient;

dist/cjs/index.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestDoneEvent = exports.RequestCancelEvent = exports.RequestErrorEvent = exports.RequestSuccessEvent = exports.RequestEvent = exports.Event = exports.Request = exports.RequestFactory = exports.Dispatcher = exports.Bag = exports.Extensions = void 0;
+const klient_1 = require("./klient");
+var extensions_1 = require("./extensions");
+Object.defineProperty(exports, "Extensions", { enumerable: true, get: function () { return extensions_1.default; } });
+var bag_1 = require("./services/bag");
+Object.defineProperty(exports, "Bag", { enumerable: true, get: function () { return bag_1.default; } });
+var dispatcher_1 = require("./services/dispatcher/dispatcher");
+Object.defineProperty(exports, "Dispatcher", { enumerable: true, get: function () { return dispatcher_1.default; } });
+var factory_1 = require("./services/request/factory");
+Object.defineProperty(exports, "RequestFactory", { enumerable: true, get: function () { return factory_1.default; } });
+var request_1 = require("./services/request/request");
+Object.defineProperty(exports, "Request", { enumerable: true, get: function () { return request_1.default; } });
+var event_1 = require("./events/event");
+Object.defineProperty(exports, "Event", { enumerable: true, get: function () { return event_1.default; } });
+var request_2 = require("./events/request/request");
+Object.defineProperty(exports, "RequestEvent", { enumerable: true, get: function () { return request_2.default; } });
+var success_1 = require("./events/request/success");
+Object.defineProperty(exports, "RequestSuccessEvent", { enumerable: true, get: function () { return success_1.default; } });
+var error_1 = require("./events/request/error");
+Object.defineProperty(exports, "RequestErrorEvent", { enumerable: true, get: function () { return error_1.default; } });
+var cancel_1 = require("./events/request/cancel");
+Object.defineProperty(exports, "RequestCancelEvent", { enumerable: true, get: function () { return cancel_1.default; } });
+var done_1 = require("./events/request/done");
+Object.defineProperty(exports, "RequestDoneEvent", { enumerable: true, get: function () { return done_1.default; } });
+exports.default = klient_1.default;

dist/cjs/klient.d.ts

@@ -0,0 +1,34 @@
+import Bag from './services/bag';
+import Dispatcher from './services/dispatcher/dispatcher';
+import RequestFactory from './services/request/factory';
+import type Event from './events/event';
+import type Request from './services/request/request';
+import type { KlientRequestConfig } from './services/request/request';
+import type { Callback } from './services/dispatcher/dispatcher';
+import type { Parameters } from './parameters';
+export default class Klient<P extends Parameters = Parameters> {
+    readonly extensions: string[];
+    readonly parameters: Bag;
+    readonly services: Bag;
+    constructor(urlOrParams?: P | string);
+    get url(): string | undefined;
+    get debug(): boolean;
+    get factory(): RequestFactory;
+    get dispatcher(): Dispatcher;
+    extends(property: string, value: unknown, writable?: boolean): this;
+    load(names?: string[]): this;
+    on<T extends Event>(event: string, callback: Callback<T>, priority?: number, once?: boolean): this;
+    once<T extends Event>(event: string, callback: Callback<T>, priority?: number): this;
+    off<T extends Event>(event: string, callback: Callback<T>): this;
+    request<T = unknown>(urlOrConfig: KlientRequestConfig | string): Request<T>;
+    get<T = unknown>(url: string, config?: KlientRequestConfig): Request<T>;
+    post<T = unknown>(url: string, data: unknown, config?: KlientRequestConfig): Request<T>;
+    put<T = unknown>(url: string, data: unknown, config?: KlientRequestConfig): Request<T>;
+    patch<T = unknown>(url: string, data: unknown, config?: KlientRequestConfig): Request<T>;
+    delete<T = unknown>(url: string, config?: KlientRequestConfig): Request<T>;
+    head<T = unknown>(url: string, config?: KlientRequestConfig): Request<T>;
+    options<T = unknown>(url: string, config?: KlientRequestConfig): Request<T>;
+    file(urlOrConfig: KlientRequestConfig | string): Promise<Blob>;
+    cancelPendingRequests(): this;
+    isCancel(e: Error): boolean;
+}