@legendapp/state 3.0.0-alpha.1 → 3.0.0-alpha.2

package/sync-plugins/fetch.js

@@ -3,45 +3,58 @@
 var state = require('@legendapp/state');
 var sync = require('@legendapp/state/sync');
 
+// src/sync-plugins/fetch.ts
 function syncedFetch(props) {
-    const { get: getParam, set: setParam, getInit, setInit, valueType, onSaved, onSavedValueType, transform, ...rest } = props;
-    const get = async () => {
-        const url = state.computeSelector(getParam);
-        const response = await fetch(url, getInit);
-        if (!response.ok) {
-            throw new Error(response.statusText);
-        }
-        let value = await response[valueType || 'json']();
-        if (transform === null || transform === void 0 ? void 0 : transform.load) {
-            value = transform === null || transform === void 0 ? void 0 : transform.load(value, 'get');
-        }
-        return value;
-    };
-    let set = undefined;
-    if (setParam) {
-        set = async ({ value, node, update }) => {
-            const url = state.computeSelector(setParam);
-            const response = await fetch(url, Object.assign({ method: 'POST' }, setInit, { body: JSON.stringify(value) }));
-            if (!response.ok) {
-                throw new Error(response.statusText);
-            }
-            if (onSaved) {
-                const responseValue = await response[onSavedValueType || valueType || 'json']();
-                const transformed = (transform === null || transform === void 0 ? void 0 : transform.load) ? await transform.load(responseValue, 'set') : responseValue;
-                const currentValue = state.getNodeValue(node);
-                const valueSave = onSaved({ input: value, saved: transformed, currentValue, props });
-                update({
-                    value: valueSave,
-                });
-            }
-        };
+  const {
+    get: getParam,
+    set: setParam,
+    getInit,
+    setInit,
+    valueType,
+    onSaved,
+    onSavedValueType,
+    transform,
+    ...rest
+  } = props;
+  const get = async () => {
+    const url = state.computeSelector(getParam);
+    const response = await fetch(url, getInit);
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    let value = await response[valueType || "json"]();
+    if (transform == null ? void 0 : transform.load) {
+      value = transform == null ? void 0 : transform.load(value, "get");
     }
-    return sync.synced({
-        ...rest,
-        get,
-        set,
-    });
+    return value;
+  };
+  let set = void 0;
+  if (setParam) {
+    set = async ({ value, node, update }) => {
+      const url = state.computeSelector(setParam);
+      const response = await fetch(
+        url,
+        Object.assign({ method: "POST" }, setInit, { body: JSON.stringify(value) })
+      );
+      if (!response.ok) {
+        throw new Error(response.statusText);
+      }
+      if (onSaved) {
+        const responseValue = await response[onSavedValueType || valueType || "json"]();
+        const transformed = (transform == null ? void 0 : transform.load) ? await transform.load(responseValue, "set") : responseValue;
+        const currentValue = state.getNodeValue(node);
+        const valueSave = onSaved({ input: value, saved: transformed, currentValue, props });
+        update({
+          value: valueSave
+        });
+      }
+    };
+  }
+  return sync.synced({
+    ...rest,
+    get,
+    set
+  });
 }
 
 exports.syncedFetch = syncedFetch;
-//# sourceMappingURL=fetch.js.map

package/sync-plugins/fetch.mjs

@@ -1,45 +1,58 @@
 import { computeSelector, getNodeValue } from '@legendapp/state';
 import { synced } from '@legendapp/state/sync';
 
+// src/sync-plugins/fetch.ts
 function syncedFetch(props) {
-    const { get: getParam, set: setParam, getInit, setInit, valueType, onSaved, onSavedValueType, transform, ...rest } = props;
-    const get = async () => {
-        const url = computeSelector(getParam);
-        const response = await fetch(url, getInit);
-        if (!response.ok) {
-            throw new Error(response.statusText);
-        }
-        let value = await response[valueType || 'json']();
-        if (transform === null || transform === void 0 ? void 0 : transform.load) {
-            value = transform === null || transform === void 0 ? void 0 : transform.load(value, 'get');
-        }
-        return value;
-    };
-    let set = undefined;
-    if (setParam) {
-        set = async ({ value, node, update }) => {
-            const url = computeSelector(setParam);
-            const response = await fetch(url, Object.assign({ method: 'POST' }, setInit, { body: JSON.stringify(value) }));
-            if (!response.ok) {
-                throw new Error(response.statusText);
-            }
-            if (onSaved) {
-                const responseValue = await response[onSavedValueType || valueType || 'json']();
-                const transformed = (transform === null || transform === void 0 ? void 0 : transform.load) ? await transform.load(responseValue, 'set') : responseValue;
-                const currentValue = getNodeValue(node);
-                const valueSave = onSaved({ input: value, saved: transformed, currentValue, props });
-                update({
-                    value: valueSave,
-                });
-            }
-        };
+  const {
+    get: getParam,
+    set: setParam,
+    getInit,
+    setInit,
+    valueType,
+    onSaved,
+    onSavedValueType,
+    transform,
+    ...rest
+  } = props;
+  const get = async () => {
+    const url = computeSelector(getParam);
+    const response = await fetch(url, getInit);
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    let value = await response[valueType || "json"]();
+    if (transform == null ? void 0 : transform.load) {
+      value = transform == null ? void 0 : transform.load(value, "get");
     }
-    return synced({
-        ...rest,
-        get,
-        set,
-    });
+    return value;
+  };
+  let set = void 0;
+  if (setParam) {
+    set = async ({ value, node, update }) => {
+      const url = computeSelector(setParam);
+      const response = await fetch(
+        url,
+        Object.assign({ method: "POST" }, setInit, { body: JSON.stringify(value) })
+      );
+      if (!response.ok) {
+        throw new Error(response.statusText);
+      }
+      if (onSaved) {
+        const responseValue = await response[onSavedValueType || valueType || "json"]();
+        const transformed = (transform == null ? void 0 : transform.load) ? await transform.load(responseValue, "set") : responseValue;
+        const currentValue = getNodeValue(node);
+        const valueSave = onSaved({ input: value, saved: transformed, currentValue, props });
+        update({
+          value: valueSave
+        });
+      }
+    };
+  }
+  return synced({
+    ...rest,
+    get,
+    set
+  });
 }
 
 export { syncedFetch };
-//# sourceMappingURL=fetch.mjs.map

package/sync-plugins/keel.d.mts

@@ -0,0 +1,108 @@
+import { SyncedOptions } from '@legendapp/state/sync';
+import { SyncedCrudPropsBase, CrudAsOption, SyncedCrudReturnType, SyncedCrudPropsSingle, CrudResult, SyncedCrudPropsMany } from '@legendapp/state/sync-plugins/crud';
+
+interface KeelObjectBase {
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+type KeelKey = 'createdAt' | 'updatedAt';
+declare const KeelKeys: KeelKey[];
+type OmitKeelBuiltins<T, T2 extends string = ''> = Omit<T, KeelKey | T2>;
+type APIError = {
+    type: string;
+    message: string;
+    requestId?: string;
+};
+type APIResult<T> = Result<T, APIError>;
+type Data<T> = {
+    data: T;
+    error?: never;
+};
+type Err<U> = {
+    data?: never;
+    error: U;
+};
+type Result<T, U> = NonNullable<Data<T> | Err<U>>;
+declare function generateKeelId(): string;
+interface KeelGetParams {
+}
+interface KeelListParams<Where = {}> {
+    where: {
+        updatedAt?: {
+            after: Date;
+        };
+    } & Where;
+    after?: string;
+    first?: number;
+    last?: number;
+    before?: string;
+}
+interface KeelRealtimePlugin {
+    subscribe: (realtimeKey: string, refresh: () => void) => void;
+    setLatestChange: (realtimeKey: string, time: Date) => void;
+}
+interface SyncedKeelConfiguration extends Omit<SyncedCrudPropsBase<any>, keyof SyncedOptions | 'create' | 'update' | 'delete' | 'onSaved' | 'updatePartial' | 'fieldCreatedAt' | 'fieldUpdatedAt' | 'generateId'> {
+    client: {
+        auth: {
+            refresh: () => Promise<boolean>;
+            isAuthenticated: () => Promise<boolean>;
+        };
+        api: {
+            queries: Record<string, (i: any) => Promise<any>>;
+        };
+    };
+    realtimePlugin?: KeelRealtimePlugin;
+    as?: Exclude<CrudAsOption, 'value'>;
+    enabled?: boolean;
+    onError?: (params: APIResult<any>['error']) => void;
+}
+interface SyncedKeelPropsManyBase<TRemote, TLocal, AOption extends CrudAsOption> extends Omit<SyncedCrudPropsMany<TRemote, TLocal, AOption>, 'list'> {
+    first?: number;
+    get?: never;
+}
+interface SyncedKeelPropsManyWhere<TRemote, TLocal, AOption extends CrudAsOption, Where extends Record<string, any>> extends SyncedKeelPropsManyBase<TRemote, TLocal, AOption> {
+    list?: (params: KeelListParams<NoInfer<Where>>) => Promise<CrudResult<APIResult<{
+        results: TRemote[];
+        pageInfo: any;
+    }>>>;
+    where?: Where | (() => Where);
+}
+interface SyncedKeelPropsManyNoWhere<TRemote, TLocal, AOption extends CrudAsOption> extends SyncedKeelPropsManyBase<TRemote, TLocal, AOption> {
+    list?: (params: KeelListParams<{}>) => Promise<CrudResult<APIResult<{
+        results: TRemote[];
+        pageInfo: any;
+    }>>>;
+    where?: never | {};
+}
+type HasAnyKeys<T> = keyof T extends never ? false : true;
+type SyncedKeelPropsMany<TRemote, TLocal, AOption extends CrudAsOption, Where extends Record<string, any>> = HasAnyKeys<Where> extends true ? SyncedKeelPropsManyWhere<TRemote, TLocal, AOption, Where> : SyncedKeelPropsManyNoWhere<TRemote, TLocal, AOption>;
+interface SyncedKeelPropsSingle<TRemote, TLocal> extends Omit<SyncedCrudPropsSingle<TRemote, TLocal>, 'get'> {
+    get?: (params: KeelGetParams) => Promise<APIResult<TRemote>>;
+    first?: never;
+    where?: never;
+    list?: never;
+    as?: never;
+}
+interface SyncedKeelPropsBase<TRemote extends {
+    id: string;
+}, TLocal = TRemote> extends Omit<SyncedCrudPropsBase<TRemote, TLocal>, 'create' | 'update' | 'delete' | 'updatePartial' | 'fieldUpdatedAt' | 'fieldCreatedAt'> {
+    create?: (i: NoInfer<Partial<TRemote>>) => Promise<APIResult<NoInfer<TRemote>>>;
+    update?: (params: {
+        where: any;
+        values?: Partial<TRemote>;
+    }) => Promise<APIResult<TRemote>>;
+    delete?: (params: {
+        id: string;
+    }) => Promise<APIResult<string>>;
+}
+declare function getSyncedKeelConfiguration(): SyncedKeelConfiguration;
+declare function configureSyncedKeel(config: SyncedKeelConfiguration): void;
+declare function syncedKeel<TRemote extends {
+    id: string;
+}, TLocal = TRemote>(props: SyncedKeelPropsBase<TRemote, TLocal> & SyncedKeelPropsSingle<TRemote, TLocal>): SyncedCrudReturnType<TLocal, 'value'>;
+declare function syncedKeel<TRemote extends {
+    id: string;
+}, TLocal = TRemote, TOption extends CrudAsOption = 'object', Where extends Record<string, any> = {}>(props: SyncedKeelPropsBase<TRemote, TLocal> & SyncedKeelPropsMany<TRemote, TLocal, TOption, Where>): SyncedCrudReturnType<TLocal, Exclude<TOption, 'value'>>;
+
+export { type KeelGetParams, type KeelKey, KeelKeys, type KeelListParams, type KeelObjectBase, type KeelRealtimePlugin, type OmitKeelBuiltins, type SyncedKeelConfiguration, configureSyncedKeel, generateKeelId, getSyncedKeelConfiguration, syncedKeel };

package/sync-plugins/keel.d.ts

@@ -1,13 +1,14 @@
 import { SyncedOptions } from '@legendapp/state/sync';
-import { CrudAsOption, CrudResult, SyncedCrudPropsBase, SyncedCrudPropsMany, SyncedCrudPropsSingle, SyncedCrudReturnType } from '@legendapp/state/sync-plugins/crud';
-export interface KeelObjectBase {
+import { SyncedCrudPropsBase, CrudAsOption, SyncedCrudReturnType, SyncedCrudPropsSingle, CrudResult, SyncedCrudPropsMany } from '@legendapp/state/sync-plugins/crud';
+
+interface KeelObjectBase {
     id: string;
     createdAt: Date;
     updatedAt: Date;
 }
-export type KeelKey = 'createdAt' | 'updatedAt';
-export declare const KeelKeys: KeelKey[];
-export type OmitKeelBuiltins<T, T2 extends string = ''> = Omit<T, KeelKey | T2>;
+type KeelKey = 'createdAt' | 'updatedAt';
+declare const KeelKeys: KeelKey[];
+type OmitKeelBuiltins<T, T2 extends string = ''> = Omit<T, KeelKey | T2>;
 type APIError = {
     type: string;
     message: string;
@@ -23,10 +24,10 @@ type Err<U> = {
     error: U;
 };
 type Result<T, U> = NonNullable<Data<T> | Err<U>>;
-export declare function generateKeelId(): string;
-export interface KeelGetParams {
+declare function generateKeelId(): string;
+interface KeelGetParams {
 }
-export interface KeelListParams<Where = {}> {
+interface KeelListParams<Where = {}> {
     where: {
         updatedAt?: {
             after: Date;
@@ -37,11 +38,11 @@ export interface KeelListParams<Where = {}> {
     last?: number;
     before?: string;
 }
-export interface KeelRealtimePlugin {
+interface KeelRealtimePlugin {
     subscribe: (realtimeKey: string, refresh: () => void) => void;
     setLatestChange: (realtimeKey: string, time: Date) => void;
 }
-export interface SyncedKeelConfiguration extends Omit<SyncedCrudPropsBase<any>, keyof SyncedOptions | 'create' | 'update' | 'delete' | 'onSaved' | 'updatePartial' | 'fieldCreatedAt' | 'fieldUpdatedAt' | 'generateId'> {
+interface SyncedKeelConfiguration extends Omit<SyncedCrudPropsBase<any>, keyof SyncedOptions | 'create' | 'update' | 'delete' | 'onSaved' | 'updatePartial' | 'fieldCreatedAt' | 'fieldUpdatedAt' | 'generateId'> {
     client: {
         auth: {
             refresh: () => Promise<boolean>;
@@ -95,12 +96,13 @@ interface SyncedKeelPropsBase<TRemote extends {
         id: string;
     }) => Promise<APIResult<string>>;
 }
-export declare function getSyncedKeelConfiguration(): SyncedKeelConfiguration;
-export declare function configureSyncedKeel(config: SyncedKeelConfiguration): void;
-export declare function syncedKeel<TRemote extends {
+declare function getSyncedKeelConfiguration(): SyncedKeelConfiguration;
+declare function configureSyncedKeel(config: SyncedKeelConfiguration): void;
+declare function syncedKeel<TRemote extends {
     id: string;
 }, TLocal = TRemote>(props: SyncedKeelPropsBase<TRemote, TLocal> & SyncedKeelPropsSingle<TRemote, TLocal>): SyncedCrudReturnType<TLocal, 'value'>;
-export declare function syncedKeel<TRemote extends {
+declare function syncedKeel<TRemote extends {
     id: string;
 }, TLocal = TRemote, TOption extends CrudAsOption = 'object', Where extends Record<string, any> = {}>(props: SyncedKeelPropsBase<TRemote, TLocal> & SyncedKeelPropsMany<TRemote, TLocal, TOption, Where>): SyncedCrudReturnType<TLocal, Exclude<TOption, 'value'>>;
-export {};
+
+export { type KeelGetParams, type KeelKey, KeelKeys, type KeelListParams, type KeelObjectBase, type KeelRealtimePlugin, type OmitKeelBuiltins, type SyncedKeelConfiguration, configureSyncedKeel, generateKeelId, getSyncedKeelConfiguration, syncedKeel };