fmode-ng 0.0.95 → 0.0.97

package/lib/core/parse/datatype/acl.d.ts

@@ -0,0 +1,21 @@
+export declare class FmodeACL {
+    static _instance: any | null;
+    static bindInstance(instance: any): void;
+    private permissions;
+    constructor(aclData?: Record<string, {
+        read: boolean;
+        write: boolean;
+    }>);
+    setPublicReadAccess(allowed: boolean): this;
+    setPublicWriteAccess(allowed: boolean): this;
+    setReadAccess(userId: string | any, allowed: boolean): this;
+    setWriteAccess(userId: string | any, allowed: boolean): this;
+    getPublicReadAccess(): boolean;
+    getPublicWriteAccess(): boolean;
+    getReadAccess(userId: string | any): boolean;
+    getWriteAccess(userId: string | any): boolean;
+    toJSON(): Record<string, {
+        read: boolean;
+        write: boolean;
+    }>;
+}

package/lib/core/parse/datatype/file.d.ts

@@ -0,0 +1,21 @@
+export declare class FmodeFile {
+    static _instance: any | null;
+    static bindInstance(instance: any): void;
+    __type: "File";
+    name: string;
+    url: string;
+    data?: string | Blob | File | ArrayBuffer;
+    constructor(name: string, data: string | Blob | File | ArrayBuffer | {
+        base64: string;
+    });
+    private _base64ToArrayBuffer;
+    static save(name: string, data: any | Blob | File | ArrayBuffer | string, options?: {
+        type?: string;
+        useMasterKey?: boolean;
+    }): Promise<FmodeFile>;
+    toJSON(): {
+        __type: string;
+        name: string;
+        url: string;
+    };
+}

package/lib/core/parse/datatype/geopoint.d.ts

@@ -0,0 +1,20 @@
+export declare class FmodeGeoPoint {
+    static _instance: any | null;
+    static bindInstance(instance: any): void;
+    __type: "GeoPoint";
+    latitude: number;
+    longitude: number;
+    constructor(latitude: number, longitude: number);
+    static current(options?: {
+        enableHighAccuracy?: boolean;
+    }): Promise<FmodeGeoPoint>;
+    kilometersTo(point: FmodeGeoPoint): number;
+    milesTo(point: FmodeGeoPoint): number;
+    radiansTo(point: FmodeGeoPoint): number;
+    private _calculateDistance;
+    toJSON(): {
+        __type: string;
+        latitude: number;
+        longitude: number;
+    };
+}

package/lib/core/parse/datatype/relation.d.ts

@@ -0,0 +1,18 @@
+import { FmodeQuery } from "../fmode.query";
+import { FmodeObject } from "../fmode.object";
+export declare class FmodeRelation<T extends FmodeObject> {
+    static _instance: any | null;
+    static bindInstance(instance: any): void;
+    __type: "Relation";
+    className: string;
+    parent: FmodeObject;
+    key: string;
+    constructor(parent: FmodeObject, key: string);
+    add(objects: T | T[]): void;
+    remove(objects: T[]): void;
+    query(): FmodeQuery<T>;
+    toJSON(): {
+        __type: string;
+        className: string;
+    };
+}

package/lib/core/parse/fmode.object.d.ts

@@ -1,20 +1,17 @@
+import { FmodeRelation } from "./datatype/relation";
 type ACL = Record<string, {
     read: boolean;
     write: boolean;
 }>;
-type Pointer = {
-    __type: 'Pointer';
-    className: string;
-    objectId: string;
-};
 type File = {
     __type: 'File';
     name: string;
     url: string;
 };
-type Relation = {
-    __type: 'Relation';
+type Pointer = {
+    __type: 'Pointer';
     className: string;
+    objectId: string;
 };
 export declare class FmodeObject {
     static _instance: any | null;
@@ -48,7 +45,7 @@ export declare class FmodeObject {
     static fetchAll<T extends FmodeObject>(objects: T[], options?: {
         useMasterKey?: boolean;
     }): Promise<T[]>;
-    relation(key: string): Relation;
+    relation<T extends FmodeObject>(key: string): FmodeRelation<T>;
     static fromFile(name: string, data: Blob | File | any, type?: string): Promise<File>;
 }
 export {};

package/lib/core/parse/fmode.parse.d.ts

@@ -1,3 +1,7 @@
+import { FmodeACL } from './datatype/acl';
+import { FmodeFile } from './datatype/file';
+import { FmodeGeoPoint } from './datatype/geopoint';
+import { FmodeRelation } from './datatype/relation';
 import { FmodeObject } from './fmode.object';
 import { FmodeQuery } from './fmode.query';
 import { FmodeUser } from './fmode.user';
@@ -9,6 +13,10 @@ declare class FmodeParse {
     readonly Object: typeof FmodeObject;
     readonly Query: typeof FmodeQuery;
     readonly User: typeof FmodeUser;
+    readonly File: typeof FmodeFile;
+    readonly Relation: typeof FmodeRelation;
+    readonly ACL: typeof FmodeACL;
+    readonly GeoPoint: typeof FmodeGeoPoint;
     private constructor();
     static initialize(config: string | FmodeInitOptions): FmodeParse;
     static with(configName: string): FmodeParse;
@@ -20,5 +28,9 @@ declare const defaultExport: typeof FmodeParse & {
     Object: typeof FmodeObject;
     Query: typeof FmodeQuery;
     User: typeof FmodeUser;
+    ACL: typeof FmodeACL;
+    Relation: typeof FmodeRelation;
+    GeoPoint: typeof FmodeGeoPoint;
+    File: typeof FmodeFile;
 };
 export { FmodeParse as default, defaultExport as FmodeParse };

package/lib/core/parse/fmode.query.d.ts

@@ -96,6 +96,50 @@ export declare class FmodeQuery<T extends FmodeObject = FmodeObject> {
         latitude: number;
         longitude: number;
     }>): this;
+    /**
+     * Adds a relation constraint to the query
+     */
+    relatedTo(parent: FmodeObject, key: string): this;
+    /**
+     * Adds a relation constraint for a specific object
+     */
+    relatedToObject(parent: FmodeObject, relationKey: string): this;
+    /**
+     * Adds a relation constraint for a specific query
+     */
+    relatedToQuery(parentClass: string, relationKey: string, query: FmodeQuery): this;
+    /**
+     * Matches objects that have a pointer to the given object
+     */
+    matchesPointer(key: string, object: FmodeObject): this;
+    /**
+     * Matches objects that have a pointer to any of the given objects
+     */
+    matchesAnyPointer(key: string, objects: FmodeObject[]): this;
+    /**
+     * Finds objects in a relation (alternative to using relatedTo)
+     */
+    static findRelation<T extends FmodeObject>(parent: FmodeObject, relationKey: string, options?: {
+        useMasterKey?: boolean;
+    }): Promise<T[]>;
+    /**
+     * Counts objects in a relation
+     */
+    static countRelation(parent: FmodeObject, relationKey: string, options?: {
+        useMasterKey?: boolean;
+    }): Promise<number>;
+    /**
+     * Adds objects to a relation (static helper)
+     */
+    static addToRelation<T extends FmodeObject>(parent: FmodeObject, relationKey: string, objects: T[], options?: {
+        useMasterKey?: boolean;
+    }): Promise<void>;
+    /**
+     * Removes objects from a relation (static helper)
+     */
+    static removeFromRelation<T extends FmodeObject>(parent: FmodeObject, relationKey: string, objects: T[], options?: {
+        useMasterKey?: boolean;
+    }): Promise<void>;
     include(...keys: string[]): this;
     select(...keys: string[]): this;
     limit(count: number): this;

package/lib/person/edit-upload/edit-upload.component.d.ts

@@ -62,7 +62,7 @@ export declare class EditUploadComponent implements OnInit {
     }[];
     qiniuConf: any;
     getUptoken(): Promise<any>;
-    checkFileType(url: string): "video" | "image" | "file";
+    checkFileType(url: string): "file" | "video" | "image";
     upable(): boolean;
     imgShowing: boolean;
     fileUrl: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fmode-ng",
-  "version": "0.0.95",
+  "version": "0.0.97",
   "author": "未来全栈",
   "license": "COPYRIGHT © 未来飞马 未来全栈 www.fmode.cn All RIGHTS RESERVED",
   "exports": {