@diory/client-js 0.2.0-rc9 → 0.2.1-rc1

package/dist/connectionClient/utils/debounce.d.ts

@@ -0,0 +1 @@
+export declare function debounce(func: any, wait: number, immediate?: boolean): () => typeof func

package/dist/connectionClient/utils/debounce.js

@@ -0,0 +1,22 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.debounce = void 0
+function debounce(func, wait, immediate = false) {
+  let timeout
+  // eslint-disable-next-line func-names
+  return () => {
+    // @ts-ignore
+    const context = this
+    const args = arguments
+    // eslint-disable-next-line func-names
+    const later = function () {
+      timeout = null
+      if (!immediate) func.apply(context, args)
+    }
+    const callNow = immediate && !timeout
+    clearTimeout(timeout)
+    timeout = setTimeout(later, wait)
+    if (callNow) func.apply(context, args)
+  }
+}
+exports.debounce = debounce

package/dist/dioryClient/defaultDiograph.json

@@ -0,0 +1,24 @@
+{
+  "/": {
+    "id": "welcome-root-diory"
+  },
+  "welcome-root-diory": {
+    "id": "welcome-root-diory",
+    "text": "Room",
+    "image": "",
+    "links": [
+      {
+        "id": "welcome-diory"
+      }
+    ],
+    "modified": "2020-01-03T14:03:04.751Z"
+  },
+  "welcome-diory": {
+    "id": "welcome-diory",
+    "image": "",
+    "modified": "2020-01-03T14:03:04.751Z",
+    "text": "Welcome to Diory",
+    "latitude": 60.01366036242365,
+    "longitude": 20.007133483886722
+  }
+}

package/dist/dioryClient/defaultDiosphere.d.ts

@@ -0,0 +1,21 @@
+export declare const diosphere: {
+  rooms: {
+    '/': {
+      id: string
+      created: string
+      modified: string
+    }
+    'welcome-room': {
+      id: string
+      text: string
+      doors: never[]
+      connections: {
+        id: string
+        client: string
+        address: string
+      }[]
+      created: string
+      modified: string
+    }
+  }
+}

package/dist/dioryClient/defaultDiosphere.js

@@ -0,0 +1,26 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.diosphere = void 0
+exports.diosphere = {
+  rooms: {
+    '/': {
+      id: 'welcome-room',
+      created: '2024-03-24T14:56:21.243Z',
+      modified: '2024-03-24T14:56:21.243Z',
+    },
+    'welcome-room': {
+      id: 'welcome-room',
+      text: 'Wellcome',
+      doors: [],
+      connections: [
+        {
+          id: 'welcome-connection',
+          client: 'LocalClient',
+          address: 'public/welcome-room',
+        },
+      ],
+      created: '2024-03-24T14:56:21.243Z',
+      modified: '2024-03-24T14:56:21.243Z',
+    },
+  },
+}

package/dist/dioryClient/defaultDiosphere.json

@@ -0,0 +1,23 @@
+{
+  "rooms": {
+    "/": {
+      "id": "welcome-room",
+      "created": "2024-03-24T14:56:21.243Z",
+      "modified": "2024-03-24T14:56:21.243Z"
+    },
+    "welcome-room": {
+      "id": "welcome-room",
+      "text": "Wellcome room",
+      "doors": [],
+      "connections": [
+        {
+          "id": "welcome-room",
+          "client": "LocalClient",
+          "address": "public/welcome-room"
+        }
+      ],
+      "created": "2024-03-24T14:56:21.243Z",
+      "modified": "2024-03-24T14:56:21.243Z"
+    }
+  }
+}

package/dist/dioryClient/dioryClient.d.ts

@@ -1,5 +1,5 @@
-import { IConnectionObject, IDiosphere, IRoom, IRoomObject } from '@diory/diosphere-js';
-import { IDiograph, IDiory, IDioryObject } from '@diograph/diograph';
+import { IConnectionObject, IDiosphere, IDiosphereObject, IRoom, IRoomObject } from '@diory/diosphere-js';
+import { IDiograph, IDiographObject, IDiory, IDioryObject } from '@diograph/diograph';
 import { IDioryClient, IDataClient } from '../types';
 declare class DioryClient implements IDioryClient {
     dataClients: IDataClient[];
@@ -9,13 +9,17 @@ declare class DioryClient implements IDioryClient {
     diograph: IDiograph;
     diory?: IDiory;
     constructor(dataClients: IDataClient[]);
-    initialise: (connections: IConnectionObject[]) => Promise<IDioryClient>;
-    enterRoom: (roomObject: IRoomObject) => Promise<IRoom>;
     focusDiory: (dioryObject: IDioryObject) => IDiory;
-    getDiosphere: () => Promise<IDiosphere>;
-    saveDiosphere: () => Promise<IDiosphere>;
-    getDiograph: () => Promise<IDiograph>;
-    saveDiograph: () => Promise<IDiograph>;
-    generateDiograph: () => Promise<IDiograph>;
+    selectRoom: (roomObject: IRoomObject) => IRoom;
+    getDiographClients: (connections?: IConnectionObject[]) => import("../types").IConnectionClient[];
+    initialiseDiograph: (roomObject: IRoomObject) => Promise<IDiograph>;
+    getDiograph: (connections?: IConnectionObject[]) => Promise<IDiographObject | undefined>;
+    saveDiograph: (connections?: IConnectionObject[]) => Promise<IDiographObject>;
+    importDiograph: (connections?: IConnectionObject[]) => Promise<IDiograph>;
+    generateDiograph: (connections?: IConnectionObject[]) => Promise<IDiographObject | undefined>;
+    getDiosphereClients: (connections?: IConnectionObject[]) => import("../types").IConnectionClient[];
+    initialiseDiosphere: (connections: IConnectionObject[]) => Promise<IDiosphere>;
+    getDiosphere: (connections?: IConnectionObject[]) => Promise<IDiosphereObject | undefined>;
+    saveDiosphere: (connections?: IConnectionObject[]) => Promise<IDiosphereObject>;
 }
 export { DioryClient };

package/dist/dioryClient/dioryClient.js

@@ -4,93 +4,127 @@ exports.DioryClient = void 0;
 const diosphere_js_1 = require("@diory/diosphere-js");
 const diograph_1 = require("@diograph/diograph");
 const getConnectionClients_1 = require("../utils/getConnectionClients");
+const getDefaultDiosphere_1 = require("./getDefaultDiosphere");
+const getDefaultDiograph_1 = require("./getDefaultDiograph");
 class DioryClient {
     constructor(dataClients) {
         this.dataClients = [];
         this.connections = [];
-        this.initialise = async (connections) => {
-            this.connections = connections;
-            this.diosphere.resetRooms();
-            await this.getDiosphere();
-            await this.enterRoom({ id: '/' });
-            return this;
-        };
-        this.enterRoom = async (roomObject) => {
-            this.room = this.diosphere.getRoom(roomObject);
-            this.diograph.resetDiograph();
-            await this.getDiograph();
-            this.focusDiory({ id: '/' });
-            return this.room;
-        };
         this.focusDiory = (dioryObject) => {
             return (this.diory = this.diograph.getDiory(dioryObject));
         };
-        this.getDiosphere = async () => {
-            console.info('getDiosphere', this.connections);
-            if (this.connections) {
-                const connectionClients = (0, getConnectionClients_1.getConnectionClients)(this.dataClients, this.connections);
-                await Promise.all(connectionClients.map(async (connectionClient) => {
-                    const diosphereObject = await connectionClient.getDiosphere();
-                    console.info(diosphereObject);
-                    return this.diosphere.addDiosphere(diosphereObject);
-                }));
-            }
-            return this.diosphere;
-        };
-        this.saveDiosphere = async () => {
-            console.info('saveDiosphere', this.connections);
-            if (this.connections) {
-                const connectionClients = (0, getConnectionClients_1.getConnectionClients)(this.dataClients, this.connections);
-                await Promise.all(connectionClients.map(async (connectionClient) => {
-                    console.info(this.diosphere.toObject());
-                    await connectionClient.saveDiosphere(this.diosphere.toObject());
-                    return;
-                }));
-            }
-            return this.diosphere;
+        this.selectRoom = (roomObject) => {
+            return (this.room = this.diosphere.getRoom(roomObject));
         };
-        this.getDiograph = async () => {
-            var _a, _b;
-            console.info('getDiograph', (_a = this.room) === null || _a === void 0 ? void 0 : _a.connections);
-            if ((_b = this.room) === null || _b === void 0 ? void 0 : _b.connections) {
-                const connectionClients = (0, getConnectionClients_1.getConnectionClients)(this.dataClients, this.room.connections);
-                await Promise.all(connectionClients.map(async (connectionClient) => {
-                    const diographObject = await connectionClient.getDiograph();
-                    console.info(diographObject);
-                    this.diograph.addDiograph(diographObject);
-                    return;
-                }));
-            }
-            return this.diograph;
+        this.getDiographClients = (connections) => {
+            var _a;
+            return (0, getConnectionClients_1.getConnectionClients)(this.dataClients, connections !== null && connections !== void 0 ? connections : (_a = this.room) === null || _a === void 0 ? void 0 : _a.connections);
         };
-        this.saveDiograph = async () => {
-            var _a, _b;
-            console.info('saveDiograph', (_a = this.room) === null || _a === void 0 ? void 0 : _a.connections);
-            if ((_b = this.room) === null || _b === void 0 ? void 0 : _b.connections) {
-                const connectionClients = (0, getConnectionClients_1.getConnectionClients)(this.dataClients, this.room.connections);
-                await Promise.all(connectionClients.map(async (connectionClient) => {
-                    console.info(this.diograph.toObject());
-                    await connectionClient.saveDiograph(this.diograph.toObject());
-                    return;
-                }));
-            }
+        this.initialiseDiograph = async (roomObject) => {
+            var _a;
+            console.info('initialiseDiograph', roomObject);
+            this.selectRoom(roomObject);
+            this.diograph.resetDiograph();
+            const diographObject = (_a = (await this.getDiograph())) !== null && _a !== void 0 ? _a : (0, getDefaultDiograph_1.getDefaultDiograph)();
+            this.diograph.addDiograph(diographObject);
+            this.focusDiory({ id: '/' });
+            console.info(this.diograph.toObject());
             return this.diograph;
         };
-        this.generateDiograph = async () => {
-            var _a, _b, _c;
-            console.info('generateDiograph', (_a = this.room) === null || _a === void 0 ? void 0 : _a.connections);
-            if ((_b = this.room) === null || _b === void 0 ? void 0 : _b.connections) {
-                const connectionClients = (0, getConnectionClients_1.getConnectionClients)(this.dataClients, (_c = this.room) === null || _c === void 0 ? void 0 : _c.connections);
-                await Promise.all(connectionClients.map(async (connectionClient) => {
-                    const diographObject = await connectionClient.generateDiograph();
+        this.getDiograph = async (connections) => {
+            console.info('getDiograph', connections);
+            let diographObject;
+            await Promise.all(this.getDiographClients(connections).map(async (connectionClient) => {
+                try {
+                    diographObject = await connectionClient.getDiograph();
                     console.info(diographObject);
-                    this.diograph.addDiograph(diographObject);
-                    await connectionClient.saveDiograph(this.diograph.toObject());
-                    return;
-                }));
+                }
+                catch (error) {
+                    console.error(error);
+                }
+                return;
+            }));
+            return diographObject;
+        };
+        this.saveDiograph = async (connections) => {
+            console.info('saveDiograph', connections);
+            const diographObject = this.diograph.toObject();
+            await Promise.all(this.getDiographClients(connections).map(async (connectionClient) => {
+                await connectionClient.saveDiograph(diographObject);
+                console.info(diographObject);
+                return;
+            }));
+            return diographObject;
+        };
+        this.importDiograph = async (connections) => {
+            var _a;
+            const diographObject = await this.generateDiograph(connections);
+            if (diographObject) {
+                const diory = (_a = this.diory) === null || _a === void 0 ? void 0 : _a.toObject();
+                Object.entries(diographObject).forEach(([key, dioryObject]) => {
+                    try {
+                        key === '/' && diory
+                            ? this.diograph.addDioryLink(diory, diographObject['/'])
+                            : this.diograph.addDiory(dioryObject);
+                    }
+                    catch (error) {
+                        console.error(error);
+                    }
+                });
+                await this.saveDiograph();
+                console.info(this.diograph.toObject());
             }
             return this.diograph;
         };
+        this.generateDiograph = async (connections) => {
+            console.info('generateDiograph', connections);
+            let diographObject;
+            await Promise.all(this.getDiographClients(connections).map(async (connectionClient) => {
+                diographObject = await connectionClient.generateDiograph();
+                console.info(diographObject);
+                return;
+            }));
+            return diographObject;
+        };
+        this.getDiosphereClients = (connections) => {
+            return (0, getConnectionClients_1.getConnectionClients)(this.dataClients, connections !== null && connections !== void 0 ? connections : this.connections);
+        };
+        this.initialiseDiosphere = async (connections) => {
+            var _a;
+            console.info('initialiseDiosphere', connections);
+            this.connections = connections;
+            this.diosphere.resetRooms();
+            const diosphereObject = (_a = (await this.getDiosphere())) !== null && _a !== void 0 ? _a : (0, getDefaultDiosphere_1.getDefaultDiosphere)(connections);
+            this.diosphere.addDiosphere(diosphereObject);
+            this.selectRoom({ id: '/' });
+            console.info(this.diosphere.toObject());
+            return this.diosphere;
+        };
+        this.getDiosphere = async (connections) => {
+            console.info('getDiosphere', connections);
+            let diosphereObject;
+            await Promise.all(this.getDiosphereClients(connections).map(async (connectionClient) => {
+                try {
+                    diosphereObject = await connectionClient.getDiosphere();
+                    console.info(diosphereObject);
+                }
+                catch (error) {
+                    console.error(error);
+                }
+                return;
+            }));
+            return diosphereObject;
+        };
+        this.saveDiosphere = async (connections) => {
+            console.info('saveDiosphere', connections);
+            const diosphereObject = this.diosphere.toObject();
+            await Promise.all(this.getDiosphereClients(connections).map(async (connectionClient) => {
+                await connectionClient.saveDiosphere(diosphereObject);
+                console.info(diosphereObject);
+                return;
+            }));
+            return diosphereObject;
+        };
         this.dataClients = dataClients;
         this.diosphere = new diosphere_js_1.Diosphere();
         this.diograph = new diograph_1.Diograph();

package/dist/dioryClient/getDefaultDiograph.d.ts

@@ -0,0 +1,2 @@
+import { IDiographObject } from '@diograph/diograph';
+export declare const getDefaultDiograph: () => IDiographObject;

package/dist/dioryClient/getDefaultDiograph.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultDiograph = void 0;
+const diograph_1 = require("@diograph/diograph");
+const getDefaultDiograph = () => {
+    const diograph = new diograph_1.Diograph();
+    const diory = diograph.addDiory({
+        text: 'Welcome to Diory',
+        latlng: '60.01366036242365, 20.007133483886722',
+    });
+    diograph.addDiory({
+        text: 'Root',
+        links: [{ id: diory.id }],
+    }, '/');
+    return diograph.toObject();
+};
+exports.getDefaultDiograph = getDefaultDiograph;

package/dist/dioryClient/getDefaultDiosphere.d.ts

@@ -0,0 +1,2 @@
+import { IConnectionObject, IDiosphereObject } from '@diory/diosphere-js';
+export declare const getDefaultDiosphere: (connections: IConnectionObject[]) => IDiosphereObject;

package/dist/dioryClient/getDefaultDiosphere.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultDiosphere = void 0;
+const diosphere_js_1 = require("@diory/diosphere-js");
+const getDefaultDiosphere = (connections) => {
+    const diosphere = new diosphere_js_1.Diosphere();
+    diosphere.addRoom({
+        text: 'Room',
+        connections,
+    }, '/');
+    return diosphere.toObject();
+};
+exports.getDefaultDiosphere = getDefaultDiosphere;

package/dist/types.d.ts

@@ -44,16 +44,18 @@ export interface IConnectionClient {
 export interface IDioryClient {
     dataClients: IDataClient[];
     connections: IConnectionObject[];
-    diosphere: IDiosphere;
-    room?: IRoom;
-    diograph: IDiograph;
     diory?: IDiory;
-    initialise: (connections: IConnectionObject[]) => Promise<IDioryClient>;
-    enterRoom: (roomObject: IRoomObject) => Promise<IRoom>;
     focusDiory: (dioryObject: IDioryObject) => IDiory;
-    getDiosphere: () => Promise<IDiosphere>;
-    saveDiosphere: () => Promise<IDiosphere>;
-    getDiograph: () => Promise<IDiograph>;
-    saveDiograph: () => Promise<IDiograph>;
-    generateDiograph: () => Promise<IDiograph>;
+    room?: IRoom;
+    selectRoom: (roomObject: IRoomObject) => IRoom;
+    diograph: IDiograph;
+    initialiseDiograph: (roomObject: IRoomObject) => Promise<IDiograph>;
+    getDiograph: (connections?: IConnectionObject[]) => Promise<IDiographObject | undefined>;
+    saveDiograph: (connections?: IConnectionObject[]) => Promise<IDiographObject>;
+    importDiograph: (connections?: IConnectionObject[]) => Promise<IDiograph>;
+    generateDiograph: (connections?: IConnectionObject[]) => Promise<IDiographObject | undefined>;
+    diosphere: IDiosphere;
+    initialiseDiosphere: (connections: IConnectionObject[]) => Promise<IDiosphere>;
+    getDiosphere: (connections?: IConnectionObject[]) => Promise<IDiosphereObject | undefined>;
+    saveDiosphere: (connections?: IConnectionObject[]) => Promise<IDiosphereObject>;
 }

package/dist/utils/debounce.d.ts

@@ -0,0 +1 @@
+export declare function debounce(func: any, wait: number, immediate?: boolean): () => typeof func;

package/dist/utils/debounce.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debounce = void 0;
+function debounce(func, wait, immediate = false) {
+    let timeout;
+    // eslint-disable-next-line func-names
+    return () => {
+        // @ts-ignore
+        const context = this;
+        const args = arguments;
+        // eslint-disable-next-line func-names
+        const later = function () {
+            timeout = null;
+            if (!immediate)
+                func.apply(context, args);
+        };
+        const callNow = immediate && !timeout;
+        clearTimeout(timeout);
+        timeout = setTimeout(later, wait);
+        if (callNow)
+            func.apply(context, args);
+    };
+}
+exports.debounce = debounce;

package/dist/utils/getConnectionClients.d.ts

@@ -1,3 +1,3 @@
 import { IConnectionObject } from '@diory/diosphere-js';
 import { IConnectionClient, IDataClient } from '../types';
-export declare function getConnectionClients(dataClients: IDataClient[], connections: IConnectionObject[]): IConnectionClient[];
+export declare function getConnectionClients(dataClients: IDataClient[], connections?: IConnectionObject[]): IConnectionClient[];

package/dist/utils/getConnectionClients.js

@@ -6,9 +6,7 @@ function getDataClient(dataClients, { client }) {
     return dataClients.find(({ type }) => type === client);
 }
 function getConnectionClients(dataClients, connections) {
-    return connections
-        .filter(({ client }) => dataClients.some(({ type }) => type === client))
-        .map((connection) => {
+    return connections === null || connections === void 0 ? void 0 : connections.filter(({ client }) => dataClients.some(({ type }) => type === client)).map((connection) => {
         const dataClient = getDataClient(dataClients, connection);
         return new connectionClient_1.ConnectionClient(dataClient, connection);
     });

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@diory/client-js",
-  "version": "0.2.0-rc9",
+  "version": "0.2.1-rc1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "author": "Olli-Pekka Pohjola <op@diory.me>, Jouni Alanen <jouni@diory.me>",
   "license": "MIT",
   "dependencies": {
-    "@diograph/diograph": "0.3.0-rc14",
-    "@diograph/folder-generator": "^0.3.0-rc3",
-    "@diory/diosphere-js": "0.2.6-rc2",
+    "@diograph/diograph": "^0.3.0",
+    "@diograph/folder-generator": "^0.3.0",
+    "@diory/diosphere-js": "^0.2.6",
     "path-browserify": "^1.0.1",
     "uuid": "8.3.2"
   },

package/src/dioryClient/dioryClient.ts

@@ -1,8 +1,19 @@
-import { Diosphere, IConnectionObject, IDiosphere, IRoom, IRoomObject } from '@diory/diosphere-js'
-import { Diograph, IDiograph, IDiory, IDioryObject } from '@diograph/diograph'
+import {
+  Diosphere,
+  IConnectionObject,
+  IDiosphere,
+  IDiosphereObject,
+  IRoom,
+  IRoomObject,
+} from '@diory/diosphere-js'
+import { Diograph, IDiograph, IDiographObject, IDiory, IDioryObject } from '@diograph/diograph'
 
 import { IDioryClient, IDataClient } from '../types'
 import { getConnectionClients } from '../utils/getConnectionClients'
+import { debounce } from '../utils/debounce'
+
+import { getDefaultDiosphere } from './getDefaultDiosphere'
+import { getDefaultDiograph } from './getDefaultDiograph'
 
 class DioryClient implements IDioryClient {
   dataClients: IDataClient[] = []
@@ -22,117 +33,157 @@ class DioryClient implements IDioryClient {
     this.diograph.saveDiograph = this.saveDiograph
   }
 
-  initialise = async (connections: IConnectionObject[]): Promise<IDioryClient> => {
-    this.connections = connections
+  focusDiory = (dioryObject: IDioryObject): IDiory => {
+    return (this.diory = this.diograph.getDiory(dioryObject))
+  }
 
-    this.diosphere.resetRooms()
-    await this.getDiosphere()
-    await this.enterRoom({ id: '/' })
+  selectRoom = (roomObject: IRoomObject): IRoom => {
+    return (this.room = this.diosphere.getRoom(roomObject))
+  }
 
-    return this
+  getDiographClients = (connections?: IConnectionObject[]) => {
+    return getConnectionClients(this.dataClients, connections ?? this.room?.connections)
   }
 
-  enterRoom = async (roomObject: IRoomObject): Promise<IRoom> => {
-    this.room = this.diosphere.getRoom(roomObject)
+  initialiseDiograph = async (roomObject: IRoomObject): Promise<IDiograph> => {
+    console.info('initialiseDiograph', roomObject)
+    this.selectRoom(roomObject)
 
     this.diograph.resetDiograph()
-    await this.getDiograph()
+    const diographObject = (await this.getDiograph()) ?? getDefaultDiograph()
+    this.diograph.addDiograph(diographObject)
+
     this.focusDiory({ id: '/' })
 
-    return this.room
+    console.info(this.diograph.toObject())
+    return this.diograph
   }
 
-  focusDiory = (dioryObject: IDioryObject): IDiory => {
-    return (this.diory = this.diograph.getDiory(dioryObject))
+  getDiograph = async (connections?: IConnectionObject[]): Promise<IDiographObject | undefined> => {
+    console.info('getDiograph', connections)
+
+    let diographObject
+    await Promise.all(
+      this.getDiographClients(connections).map(async (connectionClient) => {
+        try {
+          diographObject = await connectionClient.getDiograph()
+          console.info(diographObject)
+        } catch (error) {
+          console.error(error)
+        }
+        return
+      }),
+    )
+
+    return diographObject
   }
 
-  getDiosphere = async (): Promise<IDiosphere> => {
-    console.info('getDiosphere', this.connections)
-    if (this.connections) {
-      const connectionClients = getConnectionClients(this.dataClients, this.connections)
+  saveDiograph = async (connections?: IConnectionObject[]): Promise<IDiographObject> => {
+    console.info('saveDiograph', connections)
 
-      await Promise.all(
-        connectionClients.map(async (connectionClient) => {
-          const diosphereObject = await connectionClient.getDiosphere()
-          console.info(diosphereObject)
-          return this.diosphere.addDiosphere(diosphereObject)
-        }),
-      )
-    }
+    const diographObject = this.diograph.toObject()
+    await Promise.all(
+      this.getDiographClients(connections).map(async (connectionClient) => {
+        await connectionClient.saveDiograph(diographObject)
+        console.info(diographObject)
+        return
+      }),
+    )
 
-    return this.diosphere
+    return diographObject
   }
 
-  saveDiosphere = async (): Promise<IDiosphere> => {
-    console.info('saveDiosphere', this.connections)
-    if (this.connections) {
-      const connectionClients = getConnectionClients(this.dataClients, this.connections)
-
-      await Promise.all(
-        connectionClients.map(async (connectionClient) => {
-          console.info(this.diosphere.toObject())
-          await connectionClient.saveDiosphere(this.diosphere.toObject())
-          return
-        }),
-      )
+  importDiograph = async (connections?: IConnectionObject[]): Promise<IDiograph> => {
+    const diographObject = await this.generateDiograph(connections)
+
+    if (diographObject) {
+      const diory = this.diory?.toObject()
+      Object.entries(diographObject).forEach(([key, dioryObject]) => {
+        try {
+          key === '/' && diory
+            ? this.diograph.addDioryLink(diory, diographObject['/'])
+            : this.diograph.addDiory(dioryObject)
+        } catch (error) {
+          console.error(error)
+        }
+      })
+
+      await this.saveDiograph()
+      console.info(this.diograph.toObject())
     }
 
-    return this.diosphere
+    return this.diograph
   }
 
-  getDiograph = async (): Promise<IDiograph> => {
-    console.info('getDiograph', this.room?.connections)
-    if (this.room?.connections) {
-      const connectionClients = getConnectionClients(this.dataClients, this.room.connections)
-
-      await Promise.all(
-        connectionClients.map(async (connectionClient) => {
-          const diographObject = await connectionClient.getDiograph()
-          console.info(diographObject)
-          this.diograph.addDiograph(diographObject)
-          return
-        }),
-      )
-    }
+  generateDiograph = async (
+    connections?: IConnectionObject[],
+  ): Promise<IDiographObject | undefined> => {
+    console.info('generateDiograph', connections)
+
+    let diographObject
+    await Promise.all(
+      this.getDiographClients(connections).map(async (connectionClient) => {
+        diographObject = await connectionClient.generateDiograph()
+        console.info(diographObject)
+        return
+      }),
+    )
+
+    return diographObject
+  }
 
-    return this.diograph
+  getDiosphereClients = (connections?: IConnectionObject[]) => {
+    return getConnectionClients(this.dataClients, connections ?? this.connections)
   }
 
-  saveDiograph = async (): Promise<IDiograph> => {
-    console.info('saveDiograph', this.room?.connections)
-    if (this.room?.connections) {
-      const connectionClients = getConnectionClients(this.dataClients, this.room.connections)
-
-      await Promise.all(
-        connectionClients.map(async (connectionClient) => {
-          console.info(this.diograph.toObject())
-          await connectionClient.saveDiograph(this.diograph.toObject())
-          return
-        }),
-      )
-    }
+  initialiseDiosphere = async (connections: IConnectionObject[]): Promise<IDiosphere> => {
+    console.info('initialiseDiosphere', connections)
+    this.connections = connections
 
-    return this.diograph
+    this.diosphere.resetRooms()
+    const diosphereObject = (await this.getDiosphere()) ?? getDefaultDiosphere(connections)
+    this.diosphere.addDiosphere(diosphereObject)
+
+    this.selectRoom({ id: '/' })
+
+    console.info(this.diosphere.toObject())
+    return this.diosphere
   }
 
-  generateDiograph = async (): Promise<IDiograph> => {
-    console.info('generateDiograph', this.room?.connections)
-    if (this.room?.connections) {
-      const connectionClients = getConnectionClients(this.dataClients, this.room?.connections)
+  getDiosphere = async (
+    connections?: IConnectionObject[],
+  ): Promise<IDiosphereObject | undefined> => {
+    console.info('getDiosphere', connections)
 
-      await Promise.all(
-        connectionClients.map(async (connectionClient) => {
-          const diographObject = await connectionClient.generateDiograph()
-          console.info(diographObject)
-          this.diograph.addDiograph(diographObject)
+    let diosphereObject
+    await Promise.all(
+      this.getDiosphereClients(connections).map(async (connectionClient) => {
+        try {
+          diosphereObject = await connectionClient.getDiosphere()
+          console.info(diosphereObject)
+        } catch (error) {
+          console.error(error)
+        }
+        return
+      }),
+    )
+
+    return diosphereObject
+  }
 
-          await connectionClient.saveDiograph(this.diograph.toObject())
-          return
-        }),
-      )
-    }
+  saveDiosphere = async (connections?: IConnectionObject[]): Promise<IDiosphereObject> => {
+    console.info('saveDiosphere', connections)
 
-    return this.diograph
+    const diosphereObject = this.diosphere.toObject()
+    await Promise.all(
+      this.getDiosphereClients(connections).map(async (connectionClient) => {
+        await connectionClient.saveDiosphere(diosphereObject)
+        console.info(diosphereObject)
+        return
+      }),
+    )
+
+    return diosphereObject
   }
 }
 

package/src/dioryClient/getDefaultDiograph.ts

@@ -0,0 +1,18 @@
+import { Diograph, IDiographObject } from '@diograph/diograph'
+
+export const getDefaultDiograph = (): IDiographObject => {
+  const diograph = new Diograph()
+  const diory = diograph.addDiory({
+    text: 'Welcome to Diory',
+    latlng: '60.01366036242365, 20.007133483886722',
+  })
+  diograph.addDiory(
+    {
+      text: 'Root',
+      links: [{ id: diory.id }],
+    },
+    '/',
+  )
+
+  return diograph.toObject()
+}

package/src/dioryClient/getDefaultDiosphere.ts

@@ -0,0 +1,14 @@
+import { Diosphere, IConnectionObject, IDiosphereObject } from '@diory/diosphere-js'
+
+export const getDefaultDiosphere = (connections: IConnectionObject[]): IDiosphereObject => {
+  const diosphere = new Diosphere()
+  diosphere.addRoom(
+    {
+      text: 'Room',
+      connections,
+    },
+    '/',
+  )
+
+  return diosphere.toObject()
+}

package/src/types.ts

@@ -54,16 +54,18 @@ export interface IConnectionClient {
 export interface IDioryClient {
   dataClients: IDataClient[]
   connections: IConnectionObject[]
-  diosphere: IDiosphere
-  room?: IRoom
-  diograph: IDiograph
   diory?: IDiory
-  initialise: (connections: IConnectionObject[]) => Promise<IDioryClient>
-  enterRoom: (roomObject: IRoomObject) => Promise<IRoom>
   focusDiory: (dioryObject: IDioryObject) => IDiory
-  getDiosphere: () => Promise<IDiosphere>
-  saveDiosphere: () => Promise<IDiosphere>
-  getDiograph: () => Promise<IDiograph>
-  saveDiograph: () => Promise<IDiograph>
-  generateDiograph: () => Promise<IDiograph>
+  room?: IRoom
+  selectRoom: (roomObject: IRoomObject) => IRoom
+  diograph: IDiograph
+  initialiseDiograph: (roomObject: IRoomObject) => Promise<IDiograph>
+  getDiograph: (connections?: IConnectionObject[]) => Promise<IDiographObject | undefined>
+  saveDiograph: (connections?: IConnectionObject[]) => Promise<IDiographObject>
+  importDiograph: (connections?: IConnectionObject[]) => Promise<IDiograph>
+  generateDiograph: (connections?: IConnectionObject[]) => Promise<IDiographObject | undefined>
+  diosphere: IDiosphere
+  initialiseDiosphere: (connections: IConnectionObject[]) => Promise<IDiosphere>
+  getDiosphere: (connections?: IConnectionObject[]) => Promise<IDiosphereObject | undefined>
+  saveDiosphere: (connections?: IConnectionObject[]) => Promise<IDiosphereObject>
 }

package/src/utils/debounce.ts

@@ -0,0 +1,18 @@
+export function debounce(func: any, wait: number, immediate = false) {
+  let timeout: any
+  // eslint-disable-next-line func-names
+  return (): typeof func => {
+    // @ts-ignore
+    const context = this
+    const args = arguments
+    // eslint-disable-next-line func-names
+    const later = function () {
+      timeout = null
+      if (!immediate) func.apply(context, args)
+    }
+    const callNow = immediate && !timeout
+    clearTimeout(timeout)
+    timeout = setTimeout(later, wait)
+    if (callNow) func.apply(context, args)
+  }
+}

package/src/utils/getConnectionClients.ts

@@ -12,10 +12,10 @@ function getDataClient(
 
 export function getConnectionClients(
   dataClients: IDataClient[],
-  connections: IConnectionObject[],
+  connections?: IConnectionObject[],
 ): IConnectionClient[] {
   return connections
-    .filter(({ client }) => dataClients.some(({ type }) => type === client))
+    ?.filter(({ client }) => dataClients.some(({ type }) => type === client))
     .map((connection) => {
       const dataClient = getDataClient(dataClients, connection)
       return new ConnectionClient(dataClient!, connection)

package/tsconfig.json

@@ -5,7 +5,9 @@
     "target": "es2017",
     "module": "commonjs",
     "strict": true,
-    "forceConsistentCasingInFileNames": true
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "esModuleInterop": true
   },
   "exclude": ["node_modules", "dist"]
 }