Updated types to 1.4.2.

types/i18next-xhr-backend/i18next-xhr-backend-tests.ts

@@ -1,18 +1,30 @@
-import * as i18next from 'i18next';
-import XHR from 'i18next-xhr-backend';
+import * as i18next from "i18next";
+import * as XHR from "i18next-xhr-backend";
 
-let options = {
-    loadPath: '',
-    addPath: '',
+const options: XHR.BackendOptions = {
+    loadPath: "/locales/{{lng}}/{{ns}}.json",
+    addPath: "locales/add/{{lng}}/{{ns}}",
     allowMultiLoading: false,
-    parse: function(data:string) { return data.replace(/a/g, ''); },
+    parse: (data: string) => data.replace(/a/g, ""),
     crossDomain: false,
     withCredentials: false,
-    ajax: function (url:string, options:Object, callback: Function, data: Object) {}
+    ajax: (url: string, options: XHR.BackendOptions, callback: XHR.AjaxRequestCallback, data: {}) => { },
+    queryStringParams: { v: "1.3.5" }
 };
 
-i18next.use(XHR).init({
-    backend: options
-});
+i18next
+    .use(XHR)
+    .init({
+        backend: options
+    });
 
-let xhr = new XHR(null, options);
+const xhr = new XHR();
+xhr.init(options);
+const xhr2 = new XHR(null, options);
+const type: string = xhr.type;
+const newOptions: XHR.BackendOptions = xhr.options;
+xhr.create("en", "ns", "key", "value");
+xhr.create(["en", "us"], "ns", "key", "value");
+xhr.read("en", "ns", (error: any, result: string | false) => { });
+xhr.readMulti(["en"], ["ns"], (error: any, result: string | false) => { });
+xhr.loadUrl("someurl", (error: any, result: string) => { });

types/i18next-xhr-backend/index.d.ts

@@ -1,36 +1,74 @@
-// Type definitions for i18next-xhr-backend 1.2.0
+// Type definitions for i18next-xhr-backend 1.4
 // Project: https://github.com/i18next/i18next-xhr-backend
-// Definitions by: Jan Mühlemann <https://github.com/jamuhl>
+// Definitions by: Jan Mühlemann <https://github.com/jamuhl>, Giedrius Grabauskas <https://github.com/GiedriusGrabauskas>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-declare module 'i18next-xhr-backend' {
-
-    interface Interpolator {
-        interpolate: () => string
-    }
-    interface Services {
-        interpolator: Interpolator
-    }
+declare namespace I18NextXhrBackend {
+    type LoadPathOption = string | ((lngs: string[], namespaces: string[]) => string);
 
     interface BackendOptions {
-        loadPath?: string | Function,
-        addPath?:  string,
-        allowMultiLoading?: boolean,
-        parse?: Function,
-        crossDomain?: boolean,
-        withCredentials?: boolean,
-        ajax?: Function
+        /**
+         * path where resources get loaded from, or a function
+         * returning a path:
+         * function(lngs, namespaces) { return customPath; }
+         * the returned path will interpolate lng, ns if provided like giving a static path
+         */
+        loadPath?: LoadPathOption;
+        /**
+         * path to post missing resources
+         */
+        addPath?: string;
+        /**
+         * your backend server supports multiLoading
+         * locales/resources.json?lng=de+en&ns=ns1+ns2
+         * set loadPath: '/locales/resources.json?lng={{lng}}&ns={{ns}}' to adapt to multiLoading
+         */
+        allowMultiLoading?: boolean;
+        /**
+         * parse data after it has been fetched
+         * in example use https://www.npmjs.com/package/json5
+         * here it removes the letter a from the json (bad idea)
+         */
+        parse?(data: string): string;
+        /**
+         * allow cross domain requests
+         */
+        crossDomain?: boolean;
+        /**
+         * allow credentials on cross domain requests
+         */
+        withCredentials?: boolean;
+        /**
+         * define a custom xhr function
+         * can be used to support XDomainRequest in IE 8 and 9
+         */
+        ajax?(url: string, options: BackendOptions, callback: AjaxRequestCallback, data: {} | string, cache: boolean): void;
+        /**
+         * adds parameters to resource URL. 'example.com' -> 'example.com?v=1.3.5'
+         */
+        queryStringParams?: { [key: string]: string };
+
+        /**
+         * @see https://github.com/i18next/i18next-xhr-backend/blob/281c7e235e1157b33122adacef1957252e5700f1/src/ajax.js#L52
+         */
+        customHeaders?: { [key: string]: string };
     }
 
-    export default class Backend {
-        type: 'backend';
-        services: Services;
-        options: BackendOptions;
-        constructor(services?: Services, options?: BackendOptions);
-        init(services?: Services, options?: BackendOptions): void;
-        readMulti(languages: any[], namespaces: any[], callback: Function): void;
-        read(language: {}, namespace: {}, callback: Function): void;
-        loadUrl(url: string, callback: Function): void;
-        create(languages: any[], namespace: string, key: string, fallbackValue: string): void;
-    }
-}
+    type AjaxRequestCallback = (response: string, x: XMLHttpRequest) => void;
+
+    type LoadCallback = (error: any, result: string | false) => void;
+}
+
+declare class I18NextXhrBackend {
+    constructor(services?: any, options?: I18NextXhrBackend.BackendOptions);
+    init(options?: I18NextXhrBackend.BackendOptions): void;
+    readMulti(languages: string[], namespaces: string[], callback: I18NextXhrBackend.LoadCallback): void;
+    read(language: string, namespace: string, callback: I18NextXhrBackend.LoadCallback): void;
+    loadUrl(url: string, callback: I18NextXhrBackend.LoadCallback): void;
+    create(languages: string | string[], namespace: string, key: string, fallbackValue: string): void;
+    type: "backend";
+    services: any;
+    options: I18NextXhrBackend.BackendOptions;
+}
+
+export = I18NextXhrBackend;

types/i18next-xhr-backend/tsconfig.json

@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
@@ -19,4 +20,4 @@
         "index.d.ts",
         "i18next-xhr-backend-tests.ts"
     ]
-}
+}