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

package/sync-plugins/crud.d.mts

@@ -0,0 +1,54 @@
+import { SyncedGetParams, SyncedOptions, SyncedSetParams } from '@legendapp/state/sync';
+
+type CrudAsOption = 'Map' | 'object' | 'value' | 'array';
+type CrudResult<T> = T;
+interface SyncedCrudPropsSingle<TRemote, TLocal> {
+    get?: (params: SyncedGetParams) => Promise<CrudResult<TRemote | null>> | CrudResult<TRemote | null>;
+    initial?: InitialValue<TLocal, 'value'>;
+    as?: never | 'value';
+}
+interface SyncedCrudPropsMany<TRemote, TLocal, TAsOption extends CrudAsOption> {
+    list?: (params: SyncedGetParams) => Promise<CrudResult<TRemote[] | null>> | CrudResult<TRemote[] | null>;
+    as?: TAsOption;
+    initial?: InitialValue<TLocal, TAsOption>;
+}
+interface SyncedCrudOnSavedParams<TRemote extends {
+    id: string | number;
+}, TLocal> {
+    saved: TLocal;
+    input: TRemote;
+    currentValue: TLocal;
+    isCreate: boolean;
+    props: SyncedCrudPropsBase<TRemote, TLocal>;
+}
+interface SyncedCrudPropsBase<TRemote extends {
+    id: string | number;
+}, TLocal = TRemote> extends Omit<SyncedOptions<TRemote, TLocal>, 'get' | 'set' | 'initial'> {
+    create?(input: TRemote, params: SyncedSetParams<TRemote>): Promise<CrudResult<TRemote> | null | undefined>;
+    update?(input: Partial<TRemote>, params: SyncedSetParams<TRemote>): Promise<CrudResult<Partial<TRemote> | null | undefined>>;
+    delete?(input: {
+        id: TRemote['id'];
+    }, params: SyncedSetParams<TRemote>): Promise<CrudResult<any>>;
+    onSaved?(params: SyncedCrudOnSavedParams<TRemote, TLocal>): Partial<TLocal> | void;
+    onSavedUpdate?: 'createdUpdatedAt';
+    fieldUpdatedAt?: string;
+    fieldCreatedAt?: string;
+    fieldDeleted?: string;
+    updatePartial?: boolean;
+    changesSince?: 'all' | 'last-sync';
+    generateId?: () => string | number;
+}
+type InitialValue<TLocal, TAsOption extends CrudAsOption> = TAsOption extends 'Map' ? Map<string | number, TLocal> : TAsOption extends 'object' ? Record<string | number, TLocal> : TAsOption extends 'value' ? TLocal : TLocal[];
+type SyncedCrudReturnType<TLocal, TAsOption extends CrudAsOption> = TAsOption extends 'Map' ? Map<TLocal extends {
+    id: number;
+} ? number : string, TLocal> : TAsOption extends 'object' ? Record<TLocal extends {
+    id: number;
+} ? number : string, TLocal> : TAsOption extends 'value' ? TLocal : TLocal[];
+declare function syncedCrud<TRemote extends {
+    id: string | number;
+}, TLocal = TRemote>(props: SyncedCrudPropsBase<TRemote, TLocal> & SyncedCrudPropsSingle<TRemote, TLocal>): SyncedCrudReturnType<TLocal, 'value'>;
+declare function syncedCrud<TRemote extends {
+    id: string | number;
+}, TLocal = TRemote, TAsOption extends CrudAsOption = 'object'>(props: SyncedCrudPropsBase<TRemote, TLocal> & SyncedCrudPropsMany<TRemote, TLocal, TAsOption>): SyncedCrudReturnType<TLocal, Exclude<TAsOption, 'value'>>;
+
+export { type CrudAsOption, type CrudResult, type SyncedCrudOnSavedParams, type SyncedCrudPropsBase, type SyncedCrudPropsMany, type SyncedCrudPropsSingle, type SyncedCrudReturnType, syncedCrud };

package/sync-plugins/crud.d.ts

@@ -1,17 +1,18 @@
 import { SyncedGetParams, SyncedOptions, SyncedSetParams } from '@legendapp/state/sync';
-export type CrudAsOption = 'Map' | 'object' | 'value' | 'array';
-export type CrudResult<T> = T;
-export interface SyncedCrudPropsSingle<TRemote, TLocal> {
+
+type CrudAsOption = 'Map' | 'object' | 'value' | 'array';
+type CrudResult<T> = T;
+interface SyncedCrudPropsSingle<TRemote, TLocal> {
     get?: (params: SyncedGetParams) => Promise<CrudResult<TRemote | null>> | CrudResult<TRemote | null>;
     initial?: InitialValue<TLocal, 'value'>;
     as?: never | 'value';
 }
-export interface SyncedCrudPropsMany<TRemote, TLocal, TAsOption extends CrudAsOption> {
+interface SyncedCrudPropsMany<TRemote, TLocal, TAsOption extends CrudAsOption> {
     list?: (params: SyncedGetParams) => Promise<CrudResult<TRemote[] | null>> | CrudResult<TRemote[] | null>;
     as?: TAsOption;
     initial?: InitialValue<TLocal, TAsOption>;
 }
-export interface SyncedCrudOnSavedParams<TRemote extends {
+interface SyncedCrudOnSavedParams<TRemote extends {
     id: string | number;
 }, TLocal> {
     saved: TLocal;
@@ -20,7 +21,7 @@ export interface SyncedCrudOnSavedParams<TRemote extends {
     isCreate: boolean;
     props: SyncedCrudPropsBase<TRemote, TLocal>;
 }
-export interface SyncedCrudPropsBase<TRemote extends {
+interface SyncedCrudPropsBase<TRemote extends {
     id: string | number;
 }, TLocal = TRemote> extends Omit<SyncedOptions<TRemote, TLocal>, 'get' | 'set' | 'initial'> {
     create?(input: TRemote, params: SyncedSetParams<TRemote>): Promise<CrudResult<TRemote> | null | undefined>;
@@ -38,15 +39,16 @@ export interface SyncedCrudPropsBase<TRemote extends {
     generateId?: () => string | number;
 }
 type InitialValue<TLocal, TAsOption extends CrudAsOption> = TAsOption extends 'Map' ? Map<string | number, TLocal> : TAsOption extends 'object' ? Record<string | number, TLocal> : TAsOption extends 'value' ? TLocal : TLocal[];
-export type SyncedCrudReturnType<TLocal, TAsOption extends CrudAsOption> = TAsOption extends 'Map' ? Map<TLocal extends {
+type SyncedCrudReturnType<TLocal, TAsOption extends CrudAsOption> = TAsOption extends 'Map' ? Map<TLocal extends {
     id: number;
 } ? number : string, TLocal> : TAsOption extends 'object' ? Record<TLocal extends {
     id: number;
 } ? number : string, TLocal> : TAsOption extends 'value' ? TLocal : TLocal[];
-export declare function syncedCrud<TRemote extends {
+declare function syncedCrud<TRemote extends {
     id: string | number;
 }, TLocal = TRemote>(props: SyncedCrudPropsBase<TRemote, TLocal> & SyncedCrudPropsSingle<TRemote, TLocal>): SyncedCrudReturnType<TLocal, 'value'>;
-export declare function syncedCrud<TRemote extends {
+declare function syncedCrud<TRemote extends {
     id: string | number;
 }, TLocal = TRemote, TAsOption extends CrudAsOption = 'object'>(props: SyncedCrudPropsBase<TRemote, TLocal> & SyncedCrudPropsMany<TRemote, TLocal, TAsOption>): SyncedCrudReturnType<TLocal, Exclude<TAsOption, 'value'>>;
-export {};
+
+export { type CrudAsOption, type CrudResult, type SyncedCrudOnSavedParams, type SyncedCrudPropsBase, type SyncedCrudPropsMany, type SyncedCrudPropsSingle, type SyncedCrudReturnType, syncedCrud };

package/sync-plugins/crud.js

@@ -3,288 +3,271 @@
 var state = require('@legendapp/state');
 var sync = require('@legendapp/state/sync');
 
-const { clone } = state.internal;
+// src/sync-plugins/crud.ts
+var { clone } = state.internal;
 function transformOut(data, transform) {
-    return transform ? transform(clone(data)) : data;
+  return transform ? transform(clone(data)) : data;
 }
 function ensureId(obj, generateId) {
-    if (!obj.id) {
-        obj.id = generateId();
-    }
-    return obj.id;
+  if (!obj.id) {
+    obj.id = generateId();
+  }
+  return obj.id;
 }
 function onSavedCreatedUpdatedAt(mode, { saved, currentValue, isCreate, props }) {
-    const savedOut = {};
-    if (isCreate) {
-        // Update with any fields that are currently undefined
-        Object.keys(saved).forEach((key) => {
-            if (state.isNullOrUndefined(currentValue[key])) {
-                savedOut[key] = saved[key];
-            }
-        });
-    }
-    else if (mode === 'createdUpdatedAt') {
-        // Update with any fields ending in createdAt or updatedAt
-        Object.keys(saved).forEach((key) => {
-            const k = key;
-            const keyLower = key.toLowerCase();
-            if ((key === props.fieldCreatedAt ||
-                key === props.fieldUpdatedAt ||
-                keyLower.endsWith('createdat') ||
-                keyLower.endsWith('updatedat') ||
-                keyLower.endsWith('created_at') ||
-                keyLower.endsWith('updated_at')) &&
-                saved[k] instanceof Date) {
-                savedOut[k] = saved[k];
-            }
-        });
-    }
-    return savedOut;
+  const savedOut = {};
+  if (isCreate) {
+    Object.keys(saved).forEach((key) => {
+      if (state.isNullOrUndefined(currentValue[key])) {
+        savedOut[key] = saved[key];
+      }
+    });
+  } else if (mode === "createdUpdatedAt") {
+    Object.keys(saved).forEach((key) => {
+      const k = key;
+      const keyLower = key.toLowerCase();
+      if ((key === props.fieldCreatedAt || key === props.fieldUpdatedAt || keyLower.endsWith("createdat") || keyLower.endsWith("updatedat") || keyLower.endsWith("created_at") || keyLower.endsWith("updated_at")) && saved[k] instanceof Date) {
+        savedOut[k] = saved[k];
+      }
+    });
+  }
+  return savedOut;
 }
 function syncedCrud(props) {
-    const { get: getFn, list: listFn, create: createFn, update: updateFn, delete: deleteFn, transform, fieldCreatedAt, fieldUpdatedAt, fieldDeleted, updatePartial, onSaved, onSavedUpdate, mode: modeParam, changesSince, generateId, ...rest } = props;
-    let asType = props.as;
-    if (!asType) {
-        asType = (getFn ? 'value' : 'object');
+  const {
+    get: getFn,
+    list: listFn,
+    create: createFn,
+    update: updateFn,
+    delete: deleteFn,
+    transform,
+    fieldCreatedAt,
+    fieldUpdatedAt,
+    fieldDeleted,
+    updatePartial,
+    onSaved,
+    onSavedUpdate,
+    mode: modeParam,
+    changesSince,
+    generateId,
+    ...rest
+  } = props;
+  let asType = props.as;
+  if (!asType) {
+    asType = getFn ? "value" : "object";
+  }
+  const asMap = asType === "Map";
+  const asArray = asType === "array";
+  const get = getFn || listFn ? async (getParams) => {
+    const { updateLastSync, lastSync, value } = getParams;
+    if (listFn) {
+      const isLastSyncMode = changesSince === "last-sync";
+      if (isLastSyncMode && lastSync) {
+        getParams.mode = modeParam || (asType === "array" ? "append" : asType === "value" ? "set" : "assign");
+      }
+      const data = await listFn(getParams) || [];
+      let newLastSync = 0;
+      for (let i = 0; i < data.length; i++) {
+        const updated = data[i][fieldUpdatedAt] || data[i][fieldCreatedAt];
+        if (updated) {
+          newLastSync = Math.max(newLastSync, +new Date(updated));
+        }
+      }
+      if (newLastSync && newLastSync !== lastSync) {
+        updateLastSync(newLastSync);
+      }
+      let transformed = data;
+      if (transform == null ? void 0 : transform.load) {
+        transformed = await Promise.all(data.map((value2) => transform.load(value2, "get")));
+      }
+      if (asType === "value") {
+        return transformed.length > 0 ? transformed[0] : isLastSyncMode && lastSync && value || null;
+      } else {
+        const results = transformed.map(
+          (result) => result[fieldDeleted] || result.__deleted ? state.internal.symbolDelete : result
+        );
+        const out = asType === "array" ? [] : asMap ? /* @__PURE__ */ new Map() : {};
+        for (let i = 0; i < results.length; i++) {
+          let result = results[i];
+          result = result[fieldDeleted] || result.__deleted ? state.internal.symbolDelete : result;
+          if (asArray) {
+            out.push(result);
+          } else if (asMap) {
+            out.set(result.id, result);
+          } else {
+            out[result.id] = result;
+          }
+        }
+        return out;
+      }
+    } else if (getFn) {
+      const data = await getFn(getParams);
+      let transformed = data;
+      if (data) {
+        const newLastSync = data[fieldUpdatedAt] || data[fieldCreatedAt];
+        if (newLastSync && newLastSync !== lastSync) {
+          updateLastSync(newLastSync);
+        }
+        if (transform == null ? void 0 : transform.load) {
+          transformed = await transform.load(data, "get");
+        }
+      }
+      return transformed;
     }
-    const asMap = asType === 'Map';
-    const asArray = asType === 'array';
-    const get = getFn || listFn
-        ? async (getParams) => {
-            const { updateLastSync, lastSync, value } = getParams;
-            if (listFn) {
-                const isLastSyncMode = changesSince === 'last-sync';
-                if (isLastSyncMode && lastSync) {
-                    getParams.mode =
-                        modeParam || (asType === 'array' ? 'append' : asType === 'value' ? 'set' : 'assign');
-                }
-                const data = (await listFn(getParams)) || [];
-                let newLastSync = 0;
-                for (let i = 0; i < data.length; i++) {
-                    const updated = data[i][fieldUpdatedAt] || data[i][fieldCreatedAt];
-                    if (updated) {
-                        newLastSync = Math.max(newLastSync, +new Date(updated));
-                    }
-                }
-                if (newLastSync && newLastSync !== lastSync) {
-                    updateLastSync(newLastSync);
-                }
-                let transformed = data;
-                if (transform === null || transform === void 0 ? void 0 : transform.load) {
-                    transformed = await Promise.all(data.map((value) => transform.load(value, 'get')));
-                }
-                if (asType === 'value') {
-                    return transformed.length > 0
-                        ? transformed[0]
-                        : (isLastSyncMode && lastSync && value) || null;
-                }
-                else {
-                    const results = transformed.map((result) => result[fieldDeleted] || result.__deleted ? state.internal.symbolDelete : result);
-                    const out = asType === 'array' ? [] : asMap ? new Map() : {};
-                    for (let i = 0; i < results.length; i++) {
-                        let result = results[i];
-                        result = result[fieldDeleted] || result.__deleted ? state.internal.symbolDelete : result;
-                        if (asArray) {
-                            out.push(result);
-                        }
-                        else if (asMap) {
-                            out.set(result.id, result);
-                        }
-                        else {
-                            out[result.id] = result;
-                        }
-                    }
-                    return out;
-                }
-            }
-            else if (getFn) {
-                const data = await getFn(getParams);
-                let transformed = data;
-                if (data) {
-                    const newLastSync = data[fieldUpdatedAt] || data[fieldCreatedAt];
-                    if (newLastSync && newLastSync !== lastSync) {
-                        updateLastSync(newLastSync);
-                    }
-                    if (transform === null || transform === void 0 ? void 0 : transform.load) {
-                        transformed = await transform.load(data, 'get');
-                    }
-                }
-                return transformed;
+  } : void 0;
+  const set = createFn || updateFn || deleteFn ? async (params) => {
+    const { value, changes, update, retryAsCreate, valuePrevious, node } = params;
+    const creates = /* @__PURE__ */ new Map();
+    const updates = /* @__PURE__ */ new Map();
+    const deletes = /* @__PURE__ */ new Set();
+    changes.forEach(({ path, prevAtPath, valueAtPath }) => {
+      if (asType === "value") {
+        if (value) {
+          let id = value == null ? void 0 : value.id;
+          const isCreate = fieldCreatedAt ? !value[fieldCreatedAt] : !prevAtPath;
+          if (!id && generateId) {
+            id = ensureId(value, generateId);
+          }
+          if (id) {
+            if (isCreate || retryAsCreate) {
+              creates.set(id, value);
+            } else if (path.length === 0) {
+              if (valueAtPath) {
+                updates.set(id, valueAtPath);
+              } else if (prevAtPath) {
+                deletes.add(prevAtPath == null ? void 0 : prevAtPath.id);
+              }
+            } else {
+              updates.set(id, Object.assign(updates.get(id) || { id }, value));
             }
+          } else {
+            console.error("[legend-state]: added synced item without an id");
+          }
+        } else if (path.length === 0) {
+          const id = prevAtPath == null ? void 0 : prevAtPath.id;
+          if (id) {
+            deletes.add(id);
+          }
         }
-        : undefined;
-    const set = createFn || updateFn || deleteFn
-        ? async (params) => {
-            const { value, changes, update, retryAsCreate, valuePrevious, node } = params;
-            const creates = new Map();
-            const updates = new Map();
-            const deletes = new Set();
-            changes.forEach(({ path, prevAtPath, valueAtPath }) => {
-                if (asType === 'value') {
-                    if (value) {
-                        let id = value === null || value === void 0 ? void 0 : value.id;
-                        const isCreate = fieldCreatedAt ? !value[fieldCreatedAt] : !prevAtPath;
-                        if (!id && generateId) {
-                            id = ensureId(value, generateId);
-                        }
-                        if (id) {
-                            if (isCreate || retryAsCreate) {
-                                creates.set(id, value);
-                            }
-                            else if (path.length === 0) {
-                                if (valueAtPath) {
-                                    updates.set(id, valueAtPath);
-                                }
-                                else if (prevAtPath) {
-                                    deletes.add(prevAtPath === null || prevAtPath === void 0 ? void 0 : prevAtPath.id);
-                                }
-                            }
-                            else {
-                                updates.set(id, Object.assign(updates.get(id) || { id }, value));
-                            }
-                        }
-                        else {
-                            console.error('[legend-state]: added synced item without an id');
-                        }
-                    }
-                    else if (path.length === 0) {
-                        const id = prevAtPath === null || prevAtPath === void 0 ? void 0 : prevAtPath.id;
-                        if (id) {
-                            deletes.add(id);
-                        }
-                    }
-                }
-                else {
-                    let itemsChanged = undefined;
-                    if (path.length === 0) {
-                        // Do a deep equal of each element vs its previous element to see which have changed
-                        itemsChanged = (asMap
-                            ? Array.from(valueAtPath.entries())
-                            : Object.entries(valueAtPath)).filter(([key, value]) => {
-                            const prev = asMap ? prevAtPath.get(key) : prevAtPath[key];
-                            const isDiff = !prevAtPath || !sync.deepEqual(value, prev);
-                            return isDiff;
-                        });
-                    }
-                    else {
-                        const itemKey = path[0];
-                        const itemValue = asMap ? value.get(itemKey) : value[itemKey];
-                        if (!itemValue) {
-                            if (path.length === 1 && prevAtPath) {
-                                deletes.add(itemKey);
-                            }
-                        }
-                        else {
-                            itemsChanged = [[itemKey, itemValue]];
-                        }
-                    }
-                    itemsChanged === null || itemsChanged === void 0 ? void 0 : itemsChanged.forEach(([itemKey, item]) => {
-                        if (state.isNullOrUndefined(item)) {
-                            deletes.add(itemKey);
-                        }
-                        else {
-                            const prev = asMap ? valuePrevious.get(itemKey) : valuePrevious[itemKey];
-                            const isCreate = fieldCreatedAt
-                                ? !item[fieldCreatedAt]
-                                : fieldUpdatedAt
-                                    ? !item[fieldUpdatedAt]
-                                    : state.isNullOrUndefined(prev);
-                            if (isCreate) {
-                                if (generateId) {
-                                    ensureId(item, generateId);
-                                }
-                                if (!item.id) {
-                                    console.error('[legend-state]: added item without an id');
-                                }
-                                if (createFn) {
-                                    creates.set(item.id, item);
-                                }
-                                else {
-                                    console.log('[legend-state] missing create function');
-                                }
-                            }
-                            else {
-                                if (updateFn) {
-                                    updates.set(item.id, item);
-                                }
-                                else {
-                                    console.log('[legend-state] missing update function');
-                                }
-                            }
-                        }
-                    });
-                }
-            });
-            const saveResult = async (itemKey, input, data, isCreate) => {
-                if (data && (onSaved || onSavedUpdate)) {
-                    const saved = ((transform === null || transform === void 0 ? void 0 : transform.load) ? transform.load(data, 'set') : data);
-                    const isChild = itemKey !== 'undefined' && asType !== 'value';
-                    const currentPeeked = state.getNodeValue(node);
-                    const currentValue = isChild ? currentPeeked === null || currentPeeked === void 0 ? void 0 : currentPeeked[itemKey] : currentPeeked;
-                    const dataOnSaved = {
-                        saved,
-                        input,
-                        currentValue,
-                        isCreate,
-                        props,
-                    };
-                    let savedOut = undefined;
-                    if (onSavedUpdate) {
-                        savedOut = onSavedCreatedUpdatedAt(onSavedUpdate, dataOnSaved);
-                    }
-                    if (onSaved) {
-                        const ret = onSaved(dataOnSaved);
-                        if (ret) {
-                            savedOut = ret;
-                        }
-                    }
-                    if (savedOut) {
-                        const createdAt = fieldCreatedAt ? savedOut[fieldCreatedAt] : undefined;
-                        const updatedAt = fieldUpdatedAt ? savedOut[fieldUpdatedAt] : undefined;
-                        const value = itemKey !== 'undefined' && asType !== 'value' ? { [itemKey]: savedOut } : savedOut;
-                        update({
-                            value,
-                            lastSync: updatedAt || createdAt ? +new Date(updatedAt || createdAt) : undefined,
-                            mode: 'merge',
-                        });
-                    }
-                }
-            };
-            return Promise.all([
-                ...Array.from(creates).map(([itemKey, itemValue]) => {
-                    const createObj = transformOut(itemValue, transform === null || transform === void 0 ? void 0 : transform.save);
-                    return createFn(createObj, params).then((result) => saveResult(itemKey, createObj, result, true));
-                }),
-                ...Array.from(updates).map(([itemKey, itemValue]) => {
-                    const toSave = updatePartial
-                        ? Object.assign(sync.diffObjects(asType === 'value' ? valuePrevious : valuePrevious[itemKey], itemValue), { id: itemValue.id })
-                        : itemValue;
-                    const changed = transformOut(toSave, transform === null || transform === void 0 ? void 0 : transform.save);
-                    if (Object.keys(changed).length > 0) {
-                        return updateFn(changed, params).then((result) => result && saveResult(itemKey, changed, result, false));
-                    }
-                }),
-                ...Array.from(deletes).map((id) => {
-                    if (deleteFn) {
-                        deleteFn({ id }, params);
-                    }
-                    else if (fieldDeleted && updateFn) {
-                        updateFn({ id, [fieldDeleted]: true }, params);
-                    }
-                    else {
-                        console.log('[legend-state] missing delete function');
-                    }
-                }),
-            ]);
+      } else {
+        let itemsChanged = void 0;
+        if (path.length === 0) {
+          itemsChanged = (asMap ? Array.from(valueAtPath.entries()) : Object.entries(valueAtPath)).filter(([key, value2]) => {
+            const prev = asMap ? prevAtPath.get(key) : prevAtPath[key];
+            const isDiff = !prevAtPath || !sync.deepEqual(value2, prev);
+            return isDiff;
+          });
+        } else {
+          const itemKey = path[0];
+          const itemValue = asMap ? value.get(itemKey) : value[itemKey];
+          if (!itemValue) {
+            if (path.length === 1 && prevAtPath) {
+              deletes.add(itemKey);
+            }
+          } else {
+            itemsChanged = [[itemKey, itemValue]];
+          }
         }
-        : undefined;
-    return sync.synced({
-        set,
-        get,
-        mode: modeParam,
-        ...rest,
+        itemsChanged == null ? void 0 : itemsChanged.forEach(([itemKey, item]) => {
+          if (state.isNullOrUndefined(item)) {
+            deletes.add(itemKey);
+          } else {
+            const prev = asMap ? valuePrevious.get(itemKey) : valuePrevious[itemKey];
+            const isCreate = fieldCreatedAt ? !item[fieldCreatedAt] : fieldUpdatedAt ? !item[fieldUpdatedAt] : state.isNullOrUndefined(prev);
+            if (isCreate) {
+              if (generateId) {
+                ensureId(item, generateId);
+              }
+              if (!item.id) {
+                console.error("[legend-state]: added item without an id");
+              }
+              if (createFn) {
+                creates.set(item.id, item);
+              } else {
+                console.log("[legend-state] missing create function");
+              }
+            } else {
+              if (updateFn) {
+                updates.set(item.id, item);
+              } else {
+                console.log("[legend-state] missing update function");
+              }
+            }
+          }
+        });
+      }
     });
+    const saveResult = async (itemKey, input, data, isCreate) => {
+      if (data && (onSaved || onSavedUpdate)) {
+        const saved = (transform == null ? void 0 : transform.load) ? transform.load(data, "set") : data;
+        const isChild = itemKey !== "undefined" && asType !== "value";
+        const currentPeeked = state.getNodeValue(node);
+        const currentValue = isChild ? currentPeeked == null ? void 0 : currentPeeked[itemKey] : currentPeeked;
+        const dataOnSaved = {
+          saved,
+          input,
+          currentValue,
+          isCreate,
+          props
+        };
+        let savedOut = void 0;
+        if (onSavedUpdate) {
+          savedOut = onSavedCreatedUpdatedAt(onSavedUpdate, dataOnSaved);
+        }
+        if (onSaved) {
+          const ret = onSaved(dataOnSaved);
+          if (ret) {
+            savedOut = ret;
+          }
+        }
+        if (savedOut) {
+          const createdAt = fieldCreatedAt ? savedOut[fieldCreatedAt] : void 0;
+          const updatedAt = fieldUpdatedAt ? savedOut[fieldUpdatedAt] : void 0;
+          const value2 = itemKey !== "undefined" && asType !== "value" ? { [itemKey]: savedOut } : savedOut;
+          update({
+            value: value2,
+            lastSync: updatedAt || createdAt ? +new Date(updatedAt || createdAt) : void 0,
+            mode: "merge"
+          });
+        }
+      }
+    };
+    return Promise.all([
+      ...Array.from(creates).map(([itemKey, itemValue]) => {
+        const createObj = transformOut(itemValue, transform == null ? void 0 : transform.save);
+        return createFn(createObj, params).then(
+          (result) => saveResult(itemKey, createObj, result, true)
+        );
+      }),
+      ...Array.from(updates).map(([itemKey, itemValue]) => {
+        const toSave = updatePartial ? Object.assign(
+          sync.diffObjects(asType === "value" ? valuePrevious : valuePrevious[itemKey], itemValue),
+          { id: itemValue.id }
+        ) : itemValue;
+        const changed = transformOut(toSave, transform == null ? void 0 : transform.save);
+        if (Object.keys(changed).length > 0) {
+          return updateFn(changed, params).then(
+            (result) => result && saveResult(itemKey, changed, result, false)
+          );
+        }
+      }),
+      ...Array.from(deletes).map((id) => {
+        if (deleteFn) {
+          deleteFn({ id }, params);
+        } else if (fieldDeleted && updateFn) {
+          updateFn({ id, [fieldDeleted]: true }, params);
+        } else {
+          console.log("[legend-state] missing delete function");
+        }
+      })
+    ]);
+  } : void 0;
+  return sync.synced({
+    set,
+    get,
+    mode: modeParam,
+    ...rest
+  });
 }
 
 exports.syncedCrud = syncedCrud;
-//# sourceMappingURL=crud.js.map