@proton-app/main 0.1.3 → 0.1.5

package/dist/communication.d.ts

@@ -1,27 +1,22 @@
 import { type IpcRenderer } from "electron";
 import Storage from "electron-store";
 export declare function setupAppIpc<T extends Record<string, any>>(storage: Storage<T>): void;
-export type IpcSchema = Record<string, Record<string, {
-    input?: unknown;
+export type IpcSchema = Record<string, {
+    input: unknown;
     result: unknown;
-}>>;
-type Input<S extends IpcSchema, N extends keyof S, K extends keyof S[N]> = S[N][K] extends {
+}>;
+type Input<S extends IpcSchema, K extends keyof S> = S[K] extends {
     input: infer I;
 } ? I : undefined;
-type Result<S extends IpcSchema, N extends keyof S, K extends keyof S[N]> = S[N][K] extends {
+type Result<S extends IpcSchema, K extends keyof S> = S[K] extends {
     result: infer R;
 } ? R : never;
-type Namespace<S extends IpcSchema, N extends keyof S> = {
-    on<K extends keyof S[N] & string>(key: K, handler: (input: Input<S, N, K>) => Result<S, N, K> | Promise<Result<S, N, K>>): void;
-};
-type Client<S extends IpcSchema> = {
-    [N in keyof S]: Namespace<S, N>;
-};
 export declare class IpcManager<S extends IpcSchema> {
+    private namespace;
     private delimiter;
-    readonly ipc: Client<S>;
-    constructor(delimiter?: string);
-    private makeNamespace;
+    readonly on: <K extends keyof S & string>(key: K, handler: (input: Input<S, K>) => Result<S, K> | Promise<Result<S, K>>) => void;
+    constructor(namespace: string, delimiter?: string);
+    private channel;
 }
 export declare const APP_CHANNELS: {
     readonly minimize: "app:minimize";
@@ -46,12 +41,13 @@ type IpcClient = Pick<IpcRenderer, "send" | "invoke">;
  * Creates the standard application controls exposed by an Electron preload.
  */
 export declare function createAppBridge(ipc: IpcClient): AppBridge;
-export type IpcApi<T> = {
-    [Namespace in keyof T]: {
-        [Handler in keyof T[Namespace]]: T[Namespace][Handler] extends {
-            input: infer Input;
-            result: infer Result;
-        } ? (input: Input) => Promise<Result> : never;
-    };
+type KebabToCamel<S extends string> = S extends `${infer A}-${infer B}` ? `${A}${Capitalize<KebabToCamel<B>>}` : S;
+type NamespaceApi<S extends IpcSchema> = {
+    [K in keyof S & string as KebabToCamel<K>]: (input: S[K]["input"]) => Promise<S[K]["result"]>;
 };
+type UnionToIntersection<U> = (U extends unknown ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
+export type IpcApi<S extends Record<string, IpcSchema>> = UnionToIntersection<{
+    [N in keyof S]: NamespaceApi<S[N]>;
+}[keyof S]>;
+export declare function createIpcManager<S extends Record<string, IpcSchema>>(): <N extends keyof S & string>(namespace: N) => IpcManager<S[N]>;
 export {};

package/dist/communication.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.APP_CHANNELS = exports.IpcManager = void 0;
 exports.setupAppIpc = setupAppIpc;
 exports.createAppBridge = createAppBridge;
+exports.createIpcManager = createIpcManager;
 const electron_1 = require("electron");
 const files_1 = require("./files");
 function setupAppIpc(storage) {
@@ -40,22 +41,19 @@ function setupAppIpc(storage) {
     });
 }
 class IpcManager {
+    namespace;
     delimiter;
-    ipc;
-    constructor(delimiter = ":") {
+    on;
+    constructor(namespace, delimiter = ":") {
+        this.namespace = namespace;
         this.delimiter = delimiter;
-        this.ipc = new Proxy({}, {
-            get: (_target, ns) => this.makeNamespace(ns),
-        });
-    }
-    makeNamespace(ns) {
-        const ch = (key) => `${ns}${this.delimiter}${key}`;
-        return {
-            on: (key, handler) => {
-                electron_1.ipcMain.handle(ch(key), (_event, input) => handler(input));
-            },
+        this.on = (key, handler) => {
+            electron_1.ipcMain.handle(this.channel(key), (_event, input) => handler(input));
         };
     }
+    channel(key) {
+        return `${this.namespace}${this.delimiter}${key}`;
+    }
 }
 exports.IpcManager = IpcManager;
 exports.APP_CHANNELS = {
@@ -95,3 +93,6 @@ function createAppBridge(ipc) {
         }
     };
 }
+function createIpcManager() {
+    return (namespace) => new IpcManager(namespace);
+}

package/dist/storage.d.ts

@@ -3,8 +3,11 @@ type StorageSchema = Record<string, {
     type: string;
     default: unknown;
 }>;
-type InferSchema<T extends StorageSchema> = {
-    [K in keyof T]: T[K]["default"];
+type BaseStorage = {
+    access_token: string | null;
+};
+type InferSchema<T extends StorageSchema> = BaseStorage & {
+    [K in Exclude<keyof T, keyof BaseStorage>]: T[K]["default"];
 };
 export declare class Storage<const T extends StorageSchema> extends ElectronStore<InferSchema<T>> {
     constructor(schema: T);

package/dist/storage.js

@@ -8,7 +8,13 @@ const electron_store_1 = __importDefault(require("electron-store"));
 class Storage extends electron_store_1.default {
     constructor(schema) {
         super({
-            schema
+            schema: {
+                access_token: {
+                    type: ["string", "null"],
+                    default: null
+                },
+                ...schema
+            }
         });
     }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
 
   "name": "@proton-app/main",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "",
   "keywords": [],
   "author": "",