document-drive 1.19.0 → 1.20.0

package/dist/src/drive-document-model/gen/schema/zod.js

@@ -0,0 +1,203 @@
+import { z } from "zod";
+export const isDefinedNonNullAny = (v) => v !== undefined && v !== null;
+export const definedNonNullAnySchema = z
+    .any()
+    .refine((v) => isDefinedNonNullAny(v));
+export const TransmitterTypeSchema = z.enum([
+    "Internal",
+    "MatrixConnect",
+    "PullResponder",
+    "RESTWebhook",
+    "SecureConnect",
+    "SwitchboardPush",
+]);
+export const TriggerTypeSchema = z.enum(["PullResponder"]);
+export function AddFileInputSchema() {
+    return z.object({
+        document: z.unknown().nullish(),
+        documentType: z.string(),
+        id: z.string(),
+        name: z.string(),
+        parentFolder: z.string().nullish(),
+        synchronizationUnits: z.array(SynchronizationUnitSchema()),
+    });
+}
+export function AddFolderInputSchema() {
+    return z.object({
+        id: z.string(),
+        name: z.string(),
+        parentFolder: z.string().nullish(),
+    });
+}
+export function AddListenerInputSchema() {
+    return z.object({
+        listener: ListenerSchema(),
+    });
+}
+export function AddTriggerInputSchema() {
+    return z.object({
+        trigger: TriggerSchema(),
+    });
+}
+export function CopyNodeInputSchema() {
+    return z.object({
+        srcId: z.string(),
+        synchronizationUnits: z.array(SynchronizationUnitSchema()).nullish(),
+        targetId: z.string(),
+        targetName: z.string().nullish(),
+        targetParentFolder: z.string().nullish(),
+    });
+}
+export function DeleteNodeInputSchema() {
+    return z.object({
+        id: z.string(),
+    });
+}
+export function DocumentDriveLocalStateSchema() {
+    return z.object({
+        __typename: z.literal("DocumentDriveLocalState").optional(),
+        availableOffline: z.boolean(),
+        listeners: z.array(ListenerSchema()),
+        sharingType: z.string().nullable(),
+        triggers: z.array(TriggerSchema()),
+    });
+}
+export function DocumentDriveStateSchema() {
+    return z.object({
+        __typename: z.literal("DocumentDriveState").optional(),
+        icon: z.string().nullable(),
+        id: z.string(),
+        name: z.string(),
+        nodes: z.array(NodeSchema()),
+        slug: z.string().nullable(),
+    });
+}
+export function FileNodeSchema() {
+    return z.object({
+        __typename: z.literal("FileNode").optional(),
+        documentType: z.string(),
+        id: z.string(),
+        kind: z.string(),
+        name: z.string(),
+        parentFolder: z.string().nullable(),
+        synchronizationUnits: z.array(SynchronizationUnitSchema()),
+    });
+}
+export function FolderNodeSchema() {
+    return z.object({
+        __typename: z.literal("FolderNode").optional(),
+        id: z.string(),
+        kind: z.string(),
+        name: z.string(),
+        parentFolder: z.string().nullable(),
+    });
+}
+export function ListenerSchema() {
+    return z.object({
+        __typename: z.literal("Listener").optional(),
+        block: z.boolean(),
+        callInfo: ListenerCallInfoSchema().nullable(),
+        filter: ListenerFilterSchema(),
+        label: z.string().nullable(),
+        listenerId: z.string(),
+        system: z.boolean(),
+    });
+}
+export function ListenerCallInfoSchema() {
+    return z.object({
+        __typename: z.literal("ListenerCallInfo").optional(),
+        data: z.string().nullable(),
+        name: z.string().nullable(),
+        transmitterType: TransmitterTypeSchema.nullable(),
+    });
+}
+export function ListenerFilterSchema() {
+    return z.object({
+        __typename: z.literal("ListenerFilter").optional(),
+        branch: z.array(z.string()).nullable(),
+        documentId: z.array(z.string()).nullable(),
+        documentType: z.array(z.string()),
+        scope: z.array(z.string()).nullable(),
+    });
+}
+export function MoveNodeInputSchema() {
+    return z.object({
+        srcFolder: z.string(),
+        targetParentFolder: z.string().nullish(),
+    });
+}
+export function NodeSchema() {
+    return z.union([FileNodeSchema(), FolderNodeSchema()]);
+}
+export function PullResponderTriggerDataSchema() {
+    return z.object({
+        __typename: z.literal("PullResponderTriggerData").optional(),
+        interval: z.string(),
+        listenerId: z.string(),
+        url: z.string(),
+    });
+}
+export function RemoveListenerInputSchema() {
+    return z.object({
+        listenerId: z.string(),
+    });
+}
+export function RemoveTriggerInputSchema() {
+    return z.object({
+        triggerId: z.string(),
+    });
+}
+export function SetAvailableOfflineInputSchema() {
+    return z.object({
+        availableOffline: z.boolean(),
+    });
+}
+export function SetDriveIconInputSchema() {
+    return z.object({
+        icon: z.string(),
+    });
+}
+export function SetDriveNameInputSchema() {
+    return z.object({
+        name: z.string(),
+    });
+}
+export function SetSharingTypeInputSchema() {
+    return z.object({
+        type: z.string(),
+    });
+}
+export function SynchronizationUnitSchema() {
+    return z.object({
+        __typename: z.literal("SynchronizationUnit").optional(),
+        branch: z.string(),
+        scope: z.string(),
+        syncId: z.string(),
+    });
+}
+export function TriggerSchema() {
+    return z.object({
+        __typename: z.literal("Trigger").optional(),
+        data: TriggerDataSchema().nullable(),
+        id: z.string(),
+        type: TriggerTypeSchema,
+    });
+}
+export function TriggerDataSchema() {
+    return PullResponderTriggerDataSchema();
+}
+export function UpdateFileInputSchema() {
+    return z.object({
+        documentType: z.string().nullish(),
+        id: z.string(),
+        name: z.string().nullish(),
+        parentFolder: z.string().nullish(),
+    });
+}
+export function UpdateNodeInputSchema() {
+    return z.object({
+        id: z.string(),
+        name: z.string().nullish(),
+        parentFolder: z.string().nullish(),
+    });
+}

package/dist/src/drive-document-model/gen/types.d.ts

@@ -0,0 +1,9 @@
+import type { DocumentModelModule, ExtendedState, PHDocument } from "document-model";
+import type { DocumentDriveAction } from "./actions.js";
+import type { DocumentDriveLocalState, DocumentDriveState } from "./schema/types.js";
+export type * from "./schema/types.js";
+export { DocumentDriveAction, DocumentDriveLocalState, DocumentDriveState };
+export type ExtendedDocumentDriveState = ExtendedState<DocumentDriveState, DocumentDriveLocalState>;
+export type DocumentDriveDocument = PHDocument<DocumentDriveState, DocumentDriveLocalState, DocumentDriveAction>;
+export type DriveDocumentModelModule = DocumentModelModule<DocumentDriveDocument>;
+//# sourceMappingURL=types.d.ts.map

package/dist/src/drive-document-model/gen/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/drive-document-model/gen/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,aAAa,EACb,UAAU,EACX,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AACxD,OAAO,KAAK,EACV,uBAAuB,EACvB,kBAAkB,EACnB,MAAM,mBAAmB,CAAC;AAC3B,mBAAmB,mBAAmB,CAAC;AACvC,OAAO,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,kBAAkB,EAAE,CAAC;AAC5E,MAAM,MAAM,0BAA0B,GAAG,aAAa,CACpD,kBAAkB,EAClB,uBAAuB,CACxB,CAAC;AACF,MAAM,MAAM,qBAAqB,GAAG,UAAU,CAC5C,kBAAkB,EAClB,uBAAuB,EACvB,mBAAmB,CACpB,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAClC,mBAAmB,CAAC,qBAAqB,CAAC,CAAC"}

package/dist/src/drive-document-model/gen/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/drive-document-model/gen/utils.d.ts

@@ -0,0 +1,10 @@
+import { CreateDocument, CreateExtendedState, CreateState, LoadFromFile, LoadFromInput, SaveToFile, SaveToFileHandle } from "document-model";
+import { DocumentDriveDocument } from "./types.js";
+export declare const createState: CreateState<DocumentDriveDocument>;
+export declare const createExtendedState: CreateExtendedState<DocumentDriveDocument>;
+export declare const createDocument: CreateDocument<DocumentDriveDocument>;
+export declare const saveToFile: SaveToFile;
+export declare const saveToFileHandle: SaveToFileHandle;
+export declare const loadFromFile: LoadFromFile<DocumentDriveDocument>;
+export declare const loadFromInput: LoadFromInput<DocumentDriveDocument>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/drive-document-model/gen/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/drive-document-model/gen/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,WAAW,EACX,YAAY,EACZ,aAAa,EACb,UAAU,EACV,gBAAgB,EAOjB,MAAM,gBAAgB,CAAC;AAQxB,OAAO,EAEL,qBAAqB,EAGtB,MAAM,YAAY,CAAC;AAEpB,eAAO,MAAM,WAAW,EAAE,WAAW,CAAC,qBAAqB,CAK1D,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,mBAAmB,CAAC,qBAAqB,CAO1E,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,qBAAqB,CAEhE,CAAC;AAEF,eAAO,MAAM,UAAU,EAAE,UAExB,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,gBAE9B,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,YAAY,CAAC,qBAAqB,CAE5D,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,aAAa,CAAC,qBAAqB,CAE9D,CAAC"}

package/dist/src/drive-document-model/gen/utils.js

@@ -0,0 +1,27 @@
+import { baseCreateDocument, baseCreateExtendedState, baseLoadFromFile, baseLoadFromInput, baseSaveToFile, baseSaveToFileHandle, } from "document-model";
+import { documentType, fileExtension, initialGlobalState, initialLocalState, } from "./constants.js";
+import { reducer } from "./reducer.js";
+export const createState = (state) => {
+    return {
+        global: { ...initialGlobalState, ...state?.global },
+        local: { ...initialLocalState, ...state?.local },
+    };
+};
+export const createExtendedState = (extendedState) => {
+    return baseCreateExtendedState({ ...extendedState, documentType }, createState);
+};
+export const createDocument = (state) => {
+    return baseCreateDocument(createExtendedState(state), createState);
+};
+export const saveToFile = (document, path, name) => {
+    return baseSaveToFile(document, path, fileExtension, name);
+};
+export const saveToFileHandle = (document, input) => {
+    return baseSaveToFileHandle(document, input);
+};
+export const loadFromFile = (path) => {
+    return baseLoadFromFile(path, reducer);
+};
+export const loadFromInput = (input) => {
+    return baseLoadFromInput(input, reducer);
+};

package/dist/src/drive-document-model/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/src/drive-document-model/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/drive-document-model/index.ts"],"names":[],"mappings":""}

package/dist/src/drive-document-model/index.js

@@ -0,0 +1 @@
+export {};

package/dist/src/drive-document-model/module.d.ts

@@ -0,0 +1,3 @@
+import { DriveDocumentModelModule } from "./gen/types.js";
+export declare const driveDocumentModelModule: DriveDocumentModelModule;
+//# sourceMappingURL=module.d.ts.map

package/dist/src/drive-document-model/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../src/drive-document-model/module.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AAI1D,eAAO,MAAM,wBAAwB,EAAE,wBAKtC,CAAC"}

package/dist/src/drive-document-model/module.js

@@ -0,0 +1,12 @@
+import * as actions from "./gen/actions.js";
+import * as creators from "./gen/creators.js";
+import { documentModelState } from "./gen/document-model.js";
+import { reducer } from "./gen/reducer.js";
+import * as documentModelUtils from "./gen/utils.js";
+import * as customUtils from "./src/utils.js";
+export const driveDocumentModelModule = {
+    reducer,
+    documentModel: documentModelState,
+    actions: { ...creators, ...actions },
+    utils: { ...documentModelUtils, ...customUtils },
+};

package/dist/src/drive-document-model/src/reducers/drive.d.ts

@@ -0,0 +1,8 @@
+/**
+ * This is a scaffold file meant for customization:
+ * - modify it by implementing the reducer functions
+ * - delete the file and run the code generator again to have it reset
+ */
+import { DocumentDriveDriveOperations } from "../../gen/drive/operations.js";
+export declare const reducer: DocumentDriveDriveOperations;
+//# sourceMappingURL=drive.d.ts.map

package/dist/src/drive-document-model/src/reducers/drive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drive.d.ts","sourceRoot":"","sources":["../../../../../src/drive-document-model/src/reducers/drive.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,4BAA4B,EAAE,MAAM,+BAA+B,CAAC;AAE7E,eAAO,MAAM,OAAO,EAAE,4BA6CrB,CAAC"}

package/dist/src/drive-document-model/src/reducers/drive.js

@@ -0,0 +1,37 @@
+/**
+ * This is a scaffold file meant for customization:
+ * - modify it by implementing the reducer functions
+ * - delete the file and run the code generator again to have it reset
+ */
+export const reducer = {
+    setDriveNameOperation(state, action, dispatch) {
+        state.name = action.input.name;
+    },
+    setDriveIconOperation(state, action, dispatch) {
+        state.icon = action.input.icon;
+    },
+    setSharingTypeOperation(state, action, dispatch) {
+        state.sharingType = action.input.type;
+    },
+    setAvailableOfflineOperation(state, action, dispatch) {
+        state.availableOffline = action.input.availableOffline;
+    },
+    addListenerOperation(state, action, dispatch) {
+        if (state.listeners.find((listener) => listener.listenerId === action.input.listener.listenerId)) {
+            throw new Error(`A listener with Id: ${action.input.listener.listenerId} already exists`);
+        }
+        state.listeners.push(action.input.listener);
+    },
+    removeListenerOperation(state, action, dispatch) {
+        state.listeners = state.listeners.filter((listener) => listener.listenerId !== action.input.listenerId);
+    },
+    addTriggerOperation(state, action, dispatch) {
+        if (state.triggers.find((trigger) => trigger.id === action.input.trigger.id)) {
+            throw new Error(`A trigger with Id: ${action.input.trigger.id} already exists`);
+        }
+        state.triggers.push(action.input.trigger);
+    },
+    removeTriggerOperation(state, action, dispatch) {
+        state.triggers = state.triggers.filter((trigger) => trigger.id !== action.input.triggerId);
+    },
+};

package/dist/src/drive-document-model/src/reducers/node.d.ts

@@ -0,0 +1,8 @@
+/**
+ * This is a scaffold file meant for customization:
+ * - modify it by implementing the reducer functions
+ * - delete the file and run the code generator again to have it reset
+ */
+import { DocumentDriveNodeOperations } from "../../gen/node/operations.js";
+export declare const reducer: DocumentDriveNodeOperations;
+//# sourceMappingURL=node.d.ts.map

package/dist/src/drive-document-model/src/reducers/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../../../src/drive-document-model/src/reducers/node.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,2BAA2B,EAAE,MAAM,8BAA8B,CAAC;AAS3E,eAAO,MAAM,OAAO,EAAE,2BAqPrB,CAAC"}

package/dist/src/drive-document-model/src/reducers/node.js

@@ -0,0 +1,185 @@
+/**
+ * This is a scaffold file meant for customization:
+ * - modify it by implementing the reducer functions
+ * - delete the file and run the code generator again to have it reset
+ */
+import { getDescendants, handleTargetNameCollisions, isFileNode, isFolderNode, } from "../utils.js";
+export const reducer = {
+    addFileOperation(state, action, dispatch) {
+        if (state.nodes.find((node) => node.id === action.input.id)) {
+            throw new Error(`Node with id ${action.input.id} already exists!`);
+        }
+        const name = handleTargetNameCollisions({
+            nodes: state.nodes,
+            srcName: action.input.name,
+            targetParentFolder: action.input.parentFolder || null,
+        });
+        const synchronizationUnits = action.input
+            .synchronizationUnits;
+        const invalidSyncUnit = synchronizationUnits.find((unit) => !!state.nodes.find((node) => isFileNode(node) &&
+            node.synchronizationUnits.find((fileUnit) => fileUnit.syncId === unit.syncId)));
+        if (invalidSyncUnit) {
+            throw new Error(`A synchronization unit with Id ${invalidSyncUnit.syncId} already exists`);
+        }
+        const fileNode = {
+            id: action.input.id,
+            name,
+            kind: "file",
+            parentFolder: action.input.parentFolder ?? null,
+            synchronizationUnits,
+            documentType: action.input.documentType,
+        };
+        state.nodes.push(fileNode);
+        dispatch?.({
+            type: "CREATE_CHILD_DOCUMENT",
+            input: {
+                id: action.input.id,
+                documentType: action.input.documentType,
+                synchronizationUnits,
+                document: action.input.document,
+            },
+        });
+    },
+    addFolderOperation(state, action) {
+        if (state.nodes.find((node) => node.id === action.input.id)) {
+            throw new Error(`Node with id ${action.input.id} already exists!`);
+        }
+        const name = handleTargetNameCollisions({
+            nodes: state.nodes,
+            srcName: action.input.name,
+            targetParentFolder: action.input.parentFolder || null,
+        });
+        state.nodes.push({
+            ...action.input,
+            name,
+            kind: "folder",
+            parentFolder: action.input.parentFolder ?? null,
+        });
+    },
+    deleteNodeOperation(state, action, dispatch) {
+        const node = state.nodes.find((node) => node.id === action.input.id);
+        if (!node) {
+            throw new Error(`Node with id ${action.input.id} not found`);
+        }
+        const descendants = getDescendants(node, state.nodes);
+        state.nodes = state.nodes.filter((node) => node.id !== action.input.id &&
+            !descendants.find((descendant) => descendant.id === node.id));
+        [node, ...descendants]
+            .filter((node) => isFileNode(node))
+            .forEach((node) => {
+            dispatch?.({
+                type: "DELETE_CHILD_DOCUMENT",
+                input: {
+                    id: node.id,
+                },
+            });
+        });
+    },
+    updateFileOperation(state, action) {
+        state.nodes = state.nodes.map((node) => node.id === action.input.id
+            ? {
+                ...node,
+                ...{
+                    name: handleTargetNameCollisions({
+                        nodes: state.nodes,
+                        srcName: action.input.name ?? node.name,
+                        targetParentFolder: action.input.parentFolder || null,
+                    }),
+                    documentType: action.input.documentType ?? node.documentType,
+                },
+            }
+            : node);
+    },
+    updateNodeOperation(state, action) {
+        state.nodes = state.nodes.map((node) => node.id === action.input.id
+            ? {
+                ...node,
+                ...{
+                    name: handleTargetNameCollisions({
+                        nodes: state.nodes,
+                        srcName: action.input.name ?? node.name,
+                        targetParentFolder: action.input.parentFolder || null,
+                    }),
+                    parentFolder: action.input.parentFolder === null ? null : node.parentFolder,
+                },
+            }
+            : node);
+    },
+    copyNodeOperation(state, action, dispatch) {
+        const node = state.nodes.find((node) => node.id === action.input.srcId);
+        if (!node) {
+            throw new Error(`Node with id ${action.input.srcId} not found`);
+        }
+        const duplicatedNode = state.nodes.find((node) => node.id === action.input.targetId);
+        if (duplicatedNode) {
+            throw new Error(`Node with id ${action.input.targetId} already exists`);
+        }
+        const name = handleTargetNameCollisions({
+            nodes: state.nodes,
+            srcName: action.input.targetName || node.name,
+            targetParentFolder: action.input.targetParentFolder || null,
+        });
+        const newNode = {
+            ...node,
+            name,
+            id: action.input.targetId,
+            parentFolder: action.input.targetParentFolder || null,
+        };
+        const isFile = isFileNode(newNode);
+        if (isFile) {
+            const synchronizationUnits = action.input
+                .synchronizationUnits;
+            if (!action.input.synchronizationUnits) {
+                throw new Error("Synchronization units were not provided");
+            }
+            const invalidSyncUnit = synchronizationUnits.find((unit) => !!state.nodes.find((node) => isFileNode(node) &&
+                node.synchronizationUnits.find((fileUnit) => fileUnit.syncId === unit.syncId)));
+            if (invalidSyncUnit) {
+                throw new Error(`A synchronization unit with Id ${invalidSyncUnit.syncId} already exists`);
+            }
+            newNode.synchronizationUnits = synchronizationUnits;
+        }
+        state.nodes.push(newNode);
+        if (isFile) {
+            dispatch?.({
+                type: "COPY_CHILD_DOCUMENT",
+                input: {
+                    id: action.input.srcId,
+                    newId: action.input.targetId,
+                    synchronizationUnits: newNode.synchronizationUnits,
+                },
+            });
+        }
+    },
+    moveNodeOperation(state, action) {
+        if (action.input.srcFolder === action.input.targetParentFolder) {
+            throw new Error("Circular Reference Error: Attempting to move a node to its current parent folder");
+        }
+        const node = state.nodes.find((node) => node.id === action.input.srcFolder);
+        if (!node) {
+            throw new Error(`Node with id ${action.input.srcFolder} not found`);
+        }
+        const name = handleTargetNameCollisions({
+            nodes: state.nodes,
+            srcName: node.name,
+            targetParentFolder: action.input.targetParentFolder || null,
+        });
+        if (isFolderNode(node)) {
+            const descendants = getDescendants(node, state.nodes);
+            // throw error if moving a folder to one of its descendants
+            if (descendants.find((descendant) => descendant.id === action.input.targetParentFolder)) {
+                throw new Error("Circular Reference Error: Cannot move a folder to one of its descendants");
+            }
+        }
+        state.nodes = state.nodes.map((node) => {
+            if (node.id === action.input.srcFolder) {
+                return {
+                    ...node,
+                    name,
+                    parentFolder: action.input.targetParentFolder || null,
+                };
+            }
+            return node;
+        });
+    },
+};

package/dist/src/drive-document-model/src/utils.d.ts

@@ -0,0 +1,34 @@
+import { OperationScope } from "document-model";
+import { AddFileAction, CopyNodeAction } from "../gen/node/actions.js";
+import { AddFileInput, CopyNodeInput, DocumentDriveState, FileNode, FolderNode, Node, SynchronizationUnit } from "../gen/types.js";
+export declare function isFileNode(node: Node): node is FileNode;
+export declare function isFolderNode(node: Node): node is FolderNode;
+export declare function getAncestors(node: Node, allNodes: Node[]): Node[];
+export declare function getDescendants(node: Node, allNodes: Node[]): Node[];
+export type GenerateNodesCopySrc = {
+    srcId: Node["id"];
+    targetName?: Node["name"];
+    targetParentFolder?: Node["parentFolder"];
+};
+export type GenerateNodesCopyIdGenerator = (prevId: Node["id"]) => Node["id"];
+/**
+ * Generates a copy of nodes based on the provided source and target information.
+ * @param src - The source information for generating the copy.
+ * @param idGenerator - The function used to generate new IDs for the copied nodes.
+ * @param nodes - The array of nodes to copy from.
+ * @returns An array of copied nodes with updated IDs and parent folders.
+ * @throws Error if the root node with the specified ID is not found.
+ */
+export declare function generateNodesCopy(src: GenerateNodesCopySrc, idGenerator: GenerateNodesCopyIdGenerator, nodes: Node[]): CopyNodeInput[];
+export declare function generateSynchronizationUnitId(nodes: DocumentDriveState["nodes"]): string;
+export declare function generateSynchronizationUnits(state: DocumentDriveState, scopes: OperationScope[], branch?: string): SynchronizationUnit[];
+export declare function generateAddNodeAction(state: DocumentDriveState, action: Omit<AddFileInput, "synchronizationUnits">, scopes: OperationScope[]): AddFileAction;
+export declare function generateCopyNodeAction(state: DocumentDriveState, action: Omit<CopyNodeInput, "synchronizationUnits">): CopyNodeAction;
+export declare function getNextCopyNumber(files: string[], baseFilename: string): number;
+export declare function escapeRegExp(string: string): string;
+export declare function handleTargetNameCollisions(params: {
+    nodes: Node[];
+    targetParentFolder: string | null;
+    srcName: string;
+}): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/drive-document-model/src/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/drive-document-model/src/utils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAEvE,OAAO,EACL,YAAY,EACZ,aAAa,EACb,kBAAkB,EAClB,QAAQ,EACR,UAAU,EACV,IAAI,EACJ,mBAAmB,EACpB,MAAM,iBAAiB,CAAC;AAEzB,wBAAgB,UAAU,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,IAAI,QAAQ,CAEvD;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,IAAI,UAAU,CAE3D;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,CAUjE;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,CAInE;AAED,MAAM,MAAM,oBAAoB,GAAG;IACjC,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;IAClB,UAAU,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IAC1B,kBAAkB,CAAC,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;CAC3C,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,CAAC;AAE9E;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,oBAAoB,EACzB,WAAW,EAAE,4BAA4B,EACzC,KAAK,EAAE,IAAI,EAAE,GACZ,aAAa,EAAE,CAmDjB;AAED,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,kBAAkB,CAAC,OAAO,CAAC,GACjC,MAAM,CAaR;AAED,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,kBAAkB,EACzB,MAAM,EAAE,cAAc,EAAE,EACxB,MAAM,SAAS,GACd,mBAAmB,EAAE,CAMvB;AAED,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,kBAAkB,EACzB,MAAM,EAAE,IAAI,CAAC,YAAY,EAAE,sBAAsB,CAAC,EAClD,MAAM,EAAE,cAAc,EAAE,GACvB,aAAa,CAKf;AAED,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,kBAAkB,EACzB,MAAM,EAAE,IAAI,CAAC,aAAa,EAAE,sBAAsB,CAAC,GAClD,cAAc,CAqBhB;AAED,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,EAAE,EACf,YAAY,EAAE,MAAM,GACnB,MAAM,CAmBR;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,UAE1C;AAED,wBAAgB,0BAA0B,CAAC,MAAM,EAAE;IACjD,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,OAAO,EAAE,MAAM,CAAC;CACjB,UAkBA"}