@opencloud-eu/web-client 0.1.0

package/dist/src/helpers/share/types.d.ts

@@ -0,0 +1,72 @@
+import { Identity, ObjectIdentity, SharingLinkType, UnifiedRoleDefinition } from '../../graph/generated';
+import { Resource } from '../resource';
+export declare enum GraphSharePermission {
+    createUpload = "libre.graph/driveItem/upload/create",
+    createPermissions = "libre.graph/driveItem/permissions/create",
+    createChildren = "libre.graph/driveItem/children/create",
+    readBasic = "libre.graph/driveItem/basic/read",
+    readPath = "libre.graph/driveItem/path/read",
+    readQuota = "libre.graph/driveItem/quota/read",
+    readContent = "libre.graph/driveItem/content/read",
+    readChildren = "libre.graph/driveItem/children/read",
+    readDeleted = "libre.graph/driveItem/deleted/read",
+    readPermissions = "libre.graph/driveItem/permissions/read",
+    readVersions = "libre.graph/driveItem/versions/read",
+    updatePath = "libre.graph/driveItem/path/update",
+    updateDeleted = "libre.graph/driveItem/deleted/update",
+    updatePermissions = "libre.graph/driveItem/permissions/update",
+    updateVersions = "libre.graph/driveItem/versions/update",
+    deleteStandard = "libre.graph/driveItem/standard/delete",
+    deleteDeleted = "libre.graph/driveItem/deleted/delete",
+    deletePermissions = "libre.graph/driveItem/permissions/delete"
+}
+export interface ShareResource extends Resource {
+    sharedWith: Array<{
+        shareType: number;
+    } & Identity>;
+    sharedBy: Identity[];
+    sdate: string;
+    outgoing: boolean;
+    driveId: string;
+}
+export interface OutgoingShareResource extends ShareResource {
+}
+export interface IncomingShareResource extends ShareResource {
+    hidden: boolean;
+    syncEnabled: boolean;
+    shareRoles: UnifiedRoleDefinition[];
+    sharePermissions: GraphSharePermission[];
+}
+export interface ShareRole extends UnifiedRoleDefinition {
+    icon?: string;
+}
+export interface Share {
+    id: string;
+    resourceId: string;
+    indirect: boolean;
+    sharedBy: Identity;
+    shareType: number;
+    createdDateTime: string;
+    expirationDateTime?: string;
+}
+export interface CollaboratorShare extends Share {
+    permissions: GraphSharePermission[];
+    sharedWith: Identity;
+    role: ShareRole;
+}
+export interface LinkShare extends Share {
+    displayName: string;
+    hasPassword: boolean;
+    isQuickLink: boolean;
+    type: SharingLinkType;
+    webUrl: string;
+    preventsDownload?: boolean;
+}
+export interface CollaboratorAutoCompleteItem {
+    id: string;
+    displayName: string;
+    shareType: number;
+    mail?: string;
+    onPremisesSamAccountName?: string;
+    identities?: ObjectIdentity[];
+}

package/dist/src/helpers/space/functions.d.ts

@@ -0,0 +1,27 @@
+import { User } from '../../graph/generated';
+import { Resource } from '../resource';
+import { PublicSpaceResource, ShareSpaceResource, SpaceMember, SpaceResource } from './types';
+import { Drive } from '@opencloud-eu/web-client/graph/generated';
+import { ShareRole } from '../share';
+export declare function buildWebDavSpacesPath(storageId: string, path?: string): string;
+export declare function buildWebDavSpacesTrashPath(storageId: string, path?: string): string;
+export declare function getRelativeSpecialFolderSpacePath(space: SpaceResource, type: 'image' | 'readme'): string;
+export declare function getSpaceManagers(space: SpaceResource): SpaceMember[];
+export type PublicLinkType = 'ocm' | 'public-link';
+export declare function buildPublicSpaceResource(data: any & {
+    publicLinkType: PublicLinkType;
+}): PublicSpaceResource;
+export declare function buildShareSpaceResource({ driveAliasPrefix, id, shareName, serverUrl }: {
+    driveAliasPrefix: 'share' | 'ocm-share';
+    id: string;
+    shareName: string;
+    serverUrl: string;
+}): ShareSpaceResource;
+export declare function buildSpace(data: Drive & {
+    path?: string;
+    serverUrl?: string;
+    webDavPath?: string;
+    webDavTrashPath?: string;
+}, graphRoles: Record<string, ShareRole>): SpaceResource;
+export declare function buildSpaceImageResource(space: SpaceResource): Resource;
+export declare function getPermissionsForSpaceMember(space: SpaceResource, user: User): string[];

package/dist/src/helpers/space/index.d.ts

@@ -0,0 +1,2 @@
+export * from './functions';
+export * from './types';

package/dist/src/helpers/space/types.d.ts

@@ -0,0 +1,84 @@
+import { DriveItem, Quota, SharePointIdentitySet, User } from '@opencloud-eu/web-client/graph/generated';
+import { Ability, Resource } from '../resource';
+export declare const SHARE_JAIL_ID = "a0ca6a90-a365-4782-871e-d44447bbc668";
+export declare const OCM_PROVIDER_ID = "89f37a33-858b-45fa-8890-a1f2b27d90e1";
+export type SpaceMember = {
+    grantedTo: SharePointIdentitySet;
+    permissions: string[];
+    roleId: string;
+};
+export interface SpaceResource extends Resource {
+    description: string;
+    disabled: boolean;
+    driveAlias: string;
+    driveType: 'mountpoint' | 'personal' | 'project' | 'share' | 'public' | (string & unknown);
+    root: DriveItem;
+    members: Record<string, SpaceMember>;
+    spaceQuota: Quota;
+    spaceImageData: DriveItem;
+    spaceReadmeData: DriveItem;
+    webDavTrashPath: string;
+    canDisable(args?: {
+        user?: User;
+        ability?: Ability;
+    }): boolean;
+    canEditDescription(args?: {
+        user?: User;
+        ability?: Ability;
+    }): boolean;
+    canEditImage(args?: {
+        user?: User;
+    }): boolean;
+    canEditReadme(args?: {
+        user?: User;
+    }): boolean;
+    canRestore(args?: {
+        user?: User;
+        ability?: Ability;
+    }): boolean;
+    canDeleteFromTrashBin(args?: {
+        user?: User;
+    }): boolean;
+    canRestoreFromTrashbin(args?: {
+        user?: User;
+    }): boolean;
+    canListVersions(args?: {
+        user?: User;
+    }): boolean;
+    getWebDavUrl({ path }: {
+        path: string;
+    }): string;
+    getWebDavTrashUrl({ path }: {
+        path: string;
+    }): string;
+    getDriveAliasAndItem(resource: Resource): string;
+    isMember(user: User): boolean;
+    isOwner(user: User): boolean;
+}
+export declare const isSpaceResource: (resource: Resource) => resource is SpaceResource;
+export interface PersonalSpaceResource extends SpaceResource {
+    __personalSpaceResource?: any;
+}
+export declare const isPersonalSpaceResource: (resource: Resource) => resource is PersonalSpaceResource;
+export interface ProjectSpaceResource extends SpaceResource {
+    __projectSpaceResource?: any;
+}
+export declare const isProjectSpaceResource: (resource: Resource) => resource is ProjectSpaceResource;
+export interface ShareSpaceResource extends SpaceResource {
+    __shareSpaceResource?: any;
+    rename(newName: string): void;
+}
+export declare const isShareSpaceResource: (resource: Resource) => resource is ShareSpaceResource;
+export interface MountPointSpaceResource extends SpaceResource {
+    __mountPointSpaceResource?: any;
+}
+export declare const isMountPointSpaceResource: (resource: Resource) => resource is MountPointSpaceResource;
+export interface PublicSpaceResource extends SpaceResource {
+    publicLinkPassword?: string;
+    publicLinkItemType?: string;
+    publicLinkPermission?: number;
+    publicLinkExpiration?: string;
+    publicLinkShareDate?: string;
+    publicLinkShareOwner?: string;
+}
+export declare const isPublicSpaceResource: (resource: Resource) => resource is PublicSpaceResource;

package/dist/src/index.d.ts

@@ -0,0 +1,19 @@
+import { AxiosInstance } from 'axios';
+import { graph, Graph } from './graph';
+import { ocs, OCS } from './ocs';
+import { WebDAV, webdav } from './webdav';
+export * from './errors';
+export * from './helpers';
+export * from './utils';
+export { graph, ocs, webdav };
+interface Client {
+    graph: Graph;
+    ocs: OCS;
+    webdav: WebDAV;
+}
+type ClientOptions = {
+    axiosClient: AxiosInstance;
+    baseURI: string;
+};
+/** @deprecated use `graph()`, `ocs()` and `webdav()` to initialize and use clients */
+export declare const client: ({ axiosClient, baseURI }: ClientOptions) => Client;

package/dist/src/ocs/capabilities.d.ts

@@ -0,0 +1,181 @@
+import { AxiosInstance } from 'axios';
+export interface AppProviderCapability {
+    apps_url?: string;
+    enabled?: boolean;
+    new_url?: string;
+    open_url?: string;
+    version?: string;
+}
+export interface PasswordPolicyCapability {
+    min_characters?: number;
+    max_characters?: number;
+    min_lowercase_characters?: number;
+    min_uppercase_characters?: number;
+    min_digits?: number;
+    min_special_characters?: number;
+}
+export interface PasswordEnforcedForCapability {
+    read_only?: boolean;
+    read_write?: boolean;
+    upload_only?: boolean;
+    read_write_delete?: boolean;
+}
+export interface SearchPropertyCapability {
+    enabled?: boolean;
+}
+export interface LastModifiedFilterCapability extends SearchPropertyCapability {
+    keywords?: string[];
+}
+export interface MediaTypeCapability extends SearchPropertyCapability {
+    keywords?: string[];
+}
+/**
+ * Archiver struct within the capabilities as defined in reva
+ * @see https://github.com/cs3org/reva/blob/41d5a6858c2200a61736d2c165e551b9785000d1/internal/http/services/owncloud/ocs/data/capabilities.go#L105
+ */
+export interface ArchiverCapability {
+    enabled?: boolean;
+    version?: string;
+    formats?: string[];
+    archiver_url?: string;
+    max_num_files?: string;
+    max_size?: string;
+}
+export interface Capabilities {
+    capabilities: {
+        checksums?: {
+            preferredUploadType?: string;
+            supportedTypes?: string[];
+        };
+        password_policy?: PasswordPolicyCapability;
+        search?: {
+            property?: {
+                content?: SearchPropertyCapability;
+                mediatype?: MediaTypeCapability;
+                mtime?: LastModifiedFilterCapability;
+                name?: MediaTypeCapability;
+                scope?: MediaTypeCapability;
+                size?: MediaTypeCapability;
+                tag?: MediaTypeCapability;
+                tags?: MediaTypeCapability;
+                type?: MediaTypeCapability;
+            };
+        };
+        notifications?: {
+            'ocs-endpoints'?: string[];
+            configurable?: boolean;
+        };
+        core: {
+            pollinterval?: number;
+            status?: {
+                edition?: string;
+                installed?: boolean;
+                maintenance?: boolean;
+                needsDbUpgrade?: boolean;
+                product?: string;
+                productname?: string;
+                productversion?: string;
+                version?: string;
+                versionstring?: string;
+            };
+            'support-sse'?: boolean;
+            'support-url-signing'?: boolean;
+            'webdav-root'?: string;
+        };
+        dav: {
+            chunking?: string;
+            chunkingParallelUploadDisabled?: boolean;
+            reports?: string[];
+            trashbin?: string;
+        };
+        files: {
+            app_providers?: AppProviderCapability[];
+            archivers?: ArchiverCapability[];
+            favorites?: boolean;
+            full_text_search?: boolean;
+            permanent_deletion?: boolean;
+            privateLinks?: boolean;
+            tags?: boolean;
+            tus_support?: {
+                extension?: string;
+                http_method_override?: boolean;
+                max_chunk_size?: number;
+                resumable?: string;
+                version?: string;
+            };
+            undelete?: boolean;
+            versioning?: boolean;
+            thumbnail?: {
+                enabled?: boolean;
+                version?: string;
+                supportedMimeTypes?: string[];
+            };
+        };
+        files_sharing: {
+            allow_custom?: boolean;
+            api_enabled?: boolean;
+            can_rename?: boolean;
+            default_permissions?: number;
+            deny_access?: boolean;
+            federation?: {
+                incoming?: boolean;
+                outgoing?: boolean;
+            };
+            group_sharing?: boolean;
+            public?: {
+                alias?: boolean;
+                can_contribute?: boolean;
+                can_edit?: boolean;
+                default_permissions?: number;
+                enabled?: boolean;
+                multiple?: boolean;
+                password?: {
+                    enforced?: boolean;
+                    enforced_for?: PasswordEnforcedForCapability;
+                };
+                send_mail?: boolean;
+                supports_upload_only?: boolean;
+                upload?: boolean;
+            };
+            search_min_length?: number;
+            user?: {
+                profile_picture?: boolean;
+                send_mail?: boolean;
+                settings?: {
+                    enabled?: boolean;
+                    version?: string;
+                }[];
+            };
+            quick_link?: {
+                default_role?: string;
+            };
+        };
+        spaces?: {
+            enabled?: boolean;
+            max_quota?: number;
+            projects?: boolean;
+            version?: string;
+        };
+        graph?: {
+            'personal-data-export'?: boolean;
+            users: {
+                change_password_self_disabled?: boolean;
+                create_disabled?: boolean;
+                delete_disabled?: boolean;
+                read_only_attributes?: string[];
+            };
+        };
+    };
+    version: {
+        edition?: string;
+        major?: string;
+        minor?: string;
+        micro?: string;
+        product?: string;
+        productversion?: string;
+        string?: string;
+    };
+}
+export declare const GetCapabilitiesFactory: (baseURI: string, axios: AxiosInstance) => {
+    getCapabilities(): Promise<Capabilities>;
+};

package/dist/src/ocs/index.d.ts

@@ -0,0 +1,8 @@
+import { Capabilities } from './capabilities';
+import { AxiosInstance } from 'axios';
+export * from './capabilities';
+export interface OCS {
+    getCapabilities: () => Promise<Capabilities>;
+    signUrl: (url: string, username: string) => Promise<string>;
+}
+export declare const ocs: (baseURI: string, axiosClient: AxiosInstance) => OCS;

package/dist/src/ocs/urlSign.d.ts

@@ -0,0 +1,18 @@
+import { AxiosInstance } from 'axios';
+export interface UrlSignOptions {
+    axiosClient: AxiosInstance;
+    baseURI: string;
+}
+export declare class UrlSign {
+    private axiosClient;
+    private baseURI;
+    private signingKey;
+    private ALGORITHM;
+    private TTL;
+    private HASH_LENGTH;
+    private ITERATION_COUNT;
+    constructor({ axiosClient, baseURI }: UrlSignOptions);
+    signUrl(url: string, username: string): Promise<string>;
+    private getSignKey;
+    private createHashedKey;
+}

package/dist/src/sse/index.d.ts

@@ -0,0 +1,50 @@
+import { FetchEventSourceInit } from '@microsoft/fetch-event-source';
+export declare enum MESSAGE_TYPE {
+    NOTIFICATION = "userlog-notification",
+    POSTPROCESSING_FINISHED = "postprocessing-finished",
+    FILE_LOCKED = "file-locked",
+    FILE_UNLOCKED = "file-unlocked",
+    FILE_TOUCHED = "file-touched",
+    ITEM_RENAMED = "item-renamed",
+    ITEM_TRASHED = "item-trashed",
+    ITEM_RESTORED = "item-restored",
+    ITEM_MOVED = "item-moved",
+    FOLDER_CREATED = "folder-created",
+    SPACE_MEMBER_ADDED = "space-member-added",
+    SPACE_MEMBER_REMOVED = "space-member-removed",
+    SPACE_SHARE_UPDATED = "space-share-updated",
+    SHARE_CREATED = "share-created",
+    SHARE_REMOVED = "share-removed",
+    SHARE_UPDATED = "share-updated",
+    LINK_CREATED = "link-created",
+    LINK_REMOVED = "link-removed",
+    LINK_UPDATED = "link-updated",
+    BACKCHANNEL_LOGOUT = "backchannel-logout"
+}
+export declare class RetriableError extends Error {
+    name: string;
+}
+export declare class SSEAdapter implements EventSource {
+    url: string;
+    fetchOptions: FetchEventSourceInit;
+    private abortController;
+    private eventListenerMap;
+    readyState: number;
+    readonly withCredentials: boolean;
+    readonly CONNECTING: 0;
+    readonly OPEN: 1;
+    readonly CLOSED: 2;
+    onerror: ((this: EventSource, ev: Event) => any) | null;
+    onmessage: ((this: EventSource, ev: MessageEvent) => any) | null;
+    onopen: ((this: EventSource, ev: Event) => any) | null;
+    constructor(url: string, fetchOptions: FetchEventSourceInit);
+    private connect;
+    fetchProvider(...args: [RequestInfo | URL, RequestInit]): Promise<Response>;
+    close(): void;
+    addEventListener<K extends keyof EventSourceEventMap>(type: string, listener: (this: EventSource, event: EventSourceEventMap[K]) => any): void;
+    removeEventListener<K extends keyof EventSourceEventMap>(type: string, listener: (this: EventSource, event: EventSourceEventMap[K]) => any): void;
+    dispatchEvent(): boolean;
+    updateAccessToken(token: string): void;
+    updateLanguage(language: string): void;
+}
+export declare const sse: (baseURI: string, fetchOptions: FetchEventSourceInit) => SSEAdapter;

package/dist/src/utils/encodePath.d.ts

@@ -0,0 +1 @@
+export declare const encodePath: (path: string) => string;

package/dist/src/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './encodePath';
+export * from './urlJoin';

package/dist/src/utils/urlJoin.d.ts

@@ -0,0 +1,19 @@
+/**
+ * A copy of https://github.com/moxystudio/js-proper-url-join/blob/master/src/index.js
+ * but without the query handling.
+ */
+export interface UrlJoinOptions {
+    /**
+     * Add a leading slash.
+     *
+     * **Default**: `true`
+     */
+    leadingSlash?: boolean | 'keep' | undefined;
+    /**
+     * Add a trailing slash.
+     *
+     * **Default**: `false`
+     */
+    trailingSlash?: boolean | 'keep' | undefined;
+}
+export declare const urlJoin: (...parts: Array<string | UrlJoinOptions>) => string;

package/dist/src/webdav/clearTrashBin.d.ts

@@ -0,0 +1,10 @@
+import { Resource, SpaceResource } from '../helpers';
+import { WebDavOptions } from './types';
+import { DAV, DAVRequestOptions } from './client';
+type ClearTrashBinOptions = {
+    id?: Resource['id'];
+} & DAVRequestOptions;
+export declare const ClearTrashBinFactory: (dav: DAV, options: WebDavOptions) => {
+    clearTrashBin(space: SpaceResource, { id, ...opts }?: ClearTrashBinOptions): Promise<import('./client').DavResult>;
+};
+export {};

package/dist/src/webdav/client/builders.d.ts

@@ -0,0 +1,8 @@
+import { DavPropertyValue } from '../constants';
+export declare const buildPropFindBody: (properties: DavPropertyValue[], { pattern, filterRules, limit, extraProps }: {
+    pattern?: string;
+    filterRules?: Partial<Record<DavPropertyValue, unknown>>;
+    limit?: number;
+    extraProps: string[];
+}) => string;
+export declare const buildPropPatchBody: (properties: Partial<Record<DavPropertyValue, unknown>>) => string;

package/dist/src/webdav/client/dav.d.ts

@@ -0,0 +1,53 @@
+import { Headers, ProgressEventCallback } from 'webdav';
+import { DavPropertyValue } from '../constants';
+import { WebDavResponseResource } from '../../helpers';
+export interface DAVOptions {
+    baseUrl: string;
+    headers?: () => Headers;
+}
+export interface DavResult {
+    body: WebDavResponseResource[] | undefined;
+    status: number;
+    result: Response;
+}
+export type DAVRequestOptions = {
+    headers?: Headers;
+    signal?: AbortSignal;
+};
+export declare class DAV {
+    private client;
+    private davPath;
+    private headers;
+    extraProps: string[];
+    constructor({ baseUrl, headers }: DAVOptions);
+    mkcol(path: string, opts?: DAVRequestOptions): Promise<DavResult>;
+    propfind(path: string, { depth, properties, headers, ...opts }?: {
+        depth?: number;
+        properties?: DavPropertyValue[];
+    } & DAVRequestOptions): Promise<WebDavResponseResource[]>;
+    report(path: string, { pattern, filterRules, limit, properties, ...opts }?: {
+        pattern?: string;
+        filterRules?: Partial<Record<DavPropertyValue, unknown>>;
+        limit?: number;
+        properties?: DavPropertyValue[];
+    } & DAVRequestOptions): Promise<{
+        results: WebDavResponseResource[];
+        range: string;
+    }>;
+    copy(source: string, target: string, { overwrite, headers, ...opts }?: {
+        overwrite?: boolean;
+    } & DAVRequestOptions): Promise<DavResult>;
+    move(source: string, target: string, { overwrite, headers, ...opts }?: {
+        overwrite?: boolean;
+    } & DAVRequestOptions): Promise<DavResult>;
+    put(path: string, content: string | ArrayBuffer, { headers, onUploadProgress, previousEntityTag, overwrite, ...opts }?: {
+        onUploadProgress?: ProgressEventCallback;
+        previousEntityTag?: string;
+        overwrite?: boolean;
+    } & DAVRequestOptions): Promise<DavResult>;
+    delete(path: string, opts?: DAVRequestOptions): Promise<DavResult>;
+    propPatch(path: string, properties: Partial<Record<DavPropertyValue, unknown>>, opts?: DAVRequestOptions): Promise<DavResult>;
+    getFileUrl(path: string): string;
+    private buildHeaders;
+    private request;
+}

package/dist/src/webdav/client/index.d.ts

@@ -0,0 +1,3 @@
+export * from './builders';
+export * from './dav';
+export * from './parsers';

package/dist/src/webdav/client/parsers.d.ts

@@ -0,0 +1,8 @@
+import { WebDavResponseResource, WebDavResponseTusSupport } from '../../helpers';
+import { DavErrorCode } from '../constants';
+export declare const parseTusHeaders: (headers: Headers) => WebDavResponseTusSupport;
+export declare const parseMultiStatus: (xmlBody: string) => Promise<WebDavResponseResource[]>;
+export declare const parseError: (xmlBody: string) => {
+    message: string;
+    errorCode: DavErrorCode;
+};