Splitted the 'WebDAVServer' class file into smaller files

lib/server/MethodCallArgs.d.ts

@@ -2,7 +2,7 @@
 import { BasicPrivilege } from '../user/privilege/IPrivilegeManager';
 import { IResource, ReturnCallback } from '../resource/IResource';
 import { XMLElement } from '../helper/XML';
-import { WebDAVServer } from '../server/WebDAVServer';
+import { WebDAVServer } from './webDAVServer/WebDAVServer';
 import { FSPath } from '../manager/FSManager';
 import { IUser } from '../user/IUser';
 import * as http from 'http';

lib/server/export.d.ts

@@ -2,4 +2,4 @@ export * from './WebDAVServerOptions';
 export * from './HTTPCodes';
 export * from './MethodCallArgs';
 export * from './WebDAVRequest';
-export * from './WebDAVServer';
+export * from './webDAVServer/WebDAVServer';

lib/server/export.js

@@ -7,4 +7,4 @@ __export(require("./WebDAVServerOptions"));
 __export(require("./HTTPCodes"));
 __export(require("./MethodCallArgs"));
 __export(require("./WebDAVRequest"));
-__export(require("./WebDAVServer"));
+__export(require("./webDAVServer/WebDAVServer"));

lib/server/webDAVServer/BeforeAfter.1.d.ts

@@ -0,0 +1,6 @@
+import { MethodCallArgs, WebDAVRequest } from '../WebDAVRequest';
+export declare function beforeRequest(manager: WebDAVRequest): void;
+export declare function afterRequest(manager: WebDAVRequest): void;
+export declare function invokeBARequest(collection: WebDAVRequest[], base: MethodCallArgs, callback: any): void;
+export declare function invokeBeforeRequest(base: MethodCallArgs, callback: any): void;
+export declare function invokeAfterRequest(base: MethodCallArgs, callback: any): void;

lib/server/webDAVServer/BeforeAfter.1.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function beforeRequest(manager) {
+    this.beforeManagers.push(manager);
+}
+exports.beforeRequest = beforeRequest;
+function afterRequest(manager) {
+    this.afterManagers.push(manager);
+}
+exports.afterRequest = afterRequest;
+function invokeBARequest(collection, base, callback) {
+    function callCallback() {
+        if (callback)
+            process.nextTick(callback);
+    }
+    if (collection.length === 0) {
+        callCallback();
+        return;
+    }
+    base.callback = next;
+    var nb = collection.length + 1;
+    function next() {
+        --nb;
+        if (nb === 0) {
+            callCallback();
+        }
+        else
+            process.nextTick(function () { return collection[collection.length - nb](base, next); });
+    }
+    next();
+}
+exports.invokeBARequest = invokeBARequest;
+function invokeBeforeRequest(base, callback) {
+    this.invokeBARequest(this.beforeManagers, base, callback);
+}
+exports.invokeBeforeRequest = invokeBeforeRequest;
+function invokeAfterRequest(base, callback) {
+    this.invokeBARequest(this.afterManagers, base, callback);
+}
+exports.invokeAfterRequest = invokeAfterRequest;

lib/server/webDAVServer/BeforeAfter.d.ts

@@ -0,0 +1,6 @@
+import { MethodCallArgs, WebDAVRequest } from '../WebDAVRequest';
+export declare function beforeRequest(manager: WebDAVRequest): void;
+export declare function afterRequest(manager: WebDAVRequest): void;
+export declare function invokeBARequest(collection: WebDAVRequest[], base: MethodCallArgs, callback: any): void;
+export declare function invokeBeforeRequest(base: MethodCallArgs, callback: any): void;
+export declare function invokeAfterRequest(base: MethodCallArgs, callback: any): void;

lib/server/webDAVServer/BeforeAfter.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function beforeRequest(manager) {
+    this.beforeManagers.push(manager);
+}
+exports.beforeRequest = beforeRequest;
+function afterRequest(manager) {
+    this.afterManagers.push(manager);
+}
+exports.afterRequest = afterRequest;
+function invokeBARequest(collection, base, callback) {
+    function callCallback() {
+        if (callback)
+            process.nextTick(callback);
+    }
+    if (collection.length === 0) {
+        callCallback();
+        return;
+    }
+    base.callback = next;
+    var nb = collection.length + 1;
+    function next() {
+        --nb;
+        if (nb === 0) {
+            callCallback();
+        }
+        else
+            process.nextTick(function () { return collection[collection.length - nb](base, next); });
+    }
+    next();
+}
+exports.invokeBARequest = invokeBARequest;
+function invokeBeforeRequest(base, callback) {
+    this.invokeBARequest(this.beforeManagers, base, callback);
+}
+exports.invokeBeforeRequest = invokeBeforeRequest;
+function invokeAfterRequest(base, callback) {
+    this.invokeBARequest(this.afterManagers, base, callback);
+}
+exports.invokeAfterRequest = invokeAfterRequest;

lib/server/webDAVServer/Persistence.1.d.ts

@@ -0,0 +1,50 @@
+/// <reference types="node" />
+import { MethodCallArgs, WebDAVRequest } from './WebDAVRequest';
+import { WebDAVServerOptions } from './WebDAVServerOptions';
+import { SerializedObject } from '../manager/ISerializer';
+import { IResource, ReturnCallback } from '../resource/IResource';
+import { HTTPAuthentication } from '../user/authentication/HTTPAuthentication';
+import { IPrivilegeManager } from '../user/privilege/IPrivilegeManager';
+import { FSManager, FSPath } from '../manager/FSManager';
+import { IUserManager } from '../user/IUserManager';
+import * as http from 'http';
+export { WebDAVServerOptions } from './WebDAVServerOptions';
+export declare type WebDAVServerStartCallback = (server?: http.Server) => void;
+export interface IResourceTreeNode {
+    r?: IResource;
+    resource?: IResource;
+    c?: ResourceTreeNode[];
+    children?: ResourceTreeNode[];
+}
+export declare type ResourceTreeNode = IResourceTreeNode | IResource | IResourceTreeNode[] | IResource[];
+export declare class WebDAVServer {
+    httpAuthentication: HTTPAuthentication;
+    privilegeManager: IPrivilegeManager;
+    rootResource: IResource;
+    userManager: IUserManager;
+    options: WebDAVServerOptions;
+    methods: object;
+    protected beforeManagers: WebDAVRequest[];
+    protected afterManagers: WebDAVRequest[];
+    protected unknownMethod: WebDAVRequest;
+    protected server: http.Server;
+    constructor(options?: WebDAVServerOptions);
+    getResourceFromPath(path: FSPath | string[] | string, callback: ReturnCallback<IResource>): any;
+    getResourceFromPath(path: FSPath | string[] | string, rootResource: IResource, callback: ReturnCallback<IResource>): any;
+    addResourceTree(resoureceTree: ResourceTreeNode, callback: (e: Error) => void): any;
+    addResourceTree(rootResource: IResource, resoureceTree: ResourceTreeNode, callback: (e: Error) => void): any;
+    onUnknownMethod(unknownMethod: WebDAVRequest): void;
+    start(port: number): any;
+    start(callback: WebDAVServerStartCallback): any;
+    start(port: number, callback: WebDAVServerStartCallback): any;
+    stop(callback: () => void): void;
+    load(obj: SerializedObject, managers: FSManager[], callback: (error: Error) => void): void;
+    save(callback: (error: Error, obj: any) => void): void;
+    method(name: string, manager: WebDAVRequest): void;
+    beforeRequest(manager: WebDAVRequest): void;
+    afterRequest(manager: WebDAVRequest): void;
+    protected normalizeMethodName(method: string): string;
+    protected invokeBARequest(collection: WebDAVRequest[], base: MethodCallArgs, callback: any): void;
+    protected invokeBeforeRequest(base: MethodCallArgs, callback: any): void;
+    protected invokeAfterRequest(base: MethodCallArgs, callback: any): void;
+}