@cyberismo/data-handler 0.0.21 → 0.0.22

package/dist/commands/move.js

@@ -10,292 +10,372 @@
   details. You should have received a copy of the GNU Affero General Public
   License along with this program. If not, see <https://www.gnu.org/licenses/>.
 */
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
 // node
 import { join } from 'node:path';
 import { ActionGuard } from '../permissions/action-guard.js';
 import { copyDir, deleteDir } from '../utils/file-utils.js';
+import { write } from '../utils/rw-lock.js';
 import { EMPTY_RANK, FIRST_RANK, getRankAfter, getRankBetween, rebalanceRanks, sortItems, } from '../utils/lexorank.js';
 import { cardPathParts, isModuleCard, isTemplateCard, } from '../utils/card-utils.js';
 import { ROOT } from '../utils/constants.js';
-export class Move {
-    project;
-    constructor(project) {
-        this.project = project;
-    }
-    // Returns children of a parent card or root cards
-    getSiblings(card) {
-        const parentCardKey = card.parent || ROOT;
-        // since we don't know if 'root' is templateRoot or cardRoot, we need to check the card
-        if (parentCardKey === ROOT) {
-            if (isTemplateCard(card)) {
-                if (isModuleCard(card)) {
-                    throw new Error(`Cannot rank module cards`);
+let Move = (() => {
+    let _instanceExtraInitializers = [];
+    let _moveCard_decorators;
+    let _rankByIndex_decorators;
+    let _rankCard_decorators;
+    let _rankFirst_decorators;
+    let _rebalanceChildren_decorators;
+    let _rebalanceProject_decorators;
+    return class Move {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _moveCard_decorators = [write((source, destination) => `Move card ${source} to ${destination}`)];
+            _rankByIndex_decorators = [write((cardKey) => `Reorder card ${cardKey}`)];
+            _rankCard_decorators = [write((cardKey) => `Reorder card ${cardKey}`)];
+            _rankFirst_decorators = [write((cardKey) => `Rank card ${cardKey} first`)];
+            _rebalanceChildren_decorators = [write((parentCardKey) => `Rebalance children of ${parentCardKey}`)];
+            _rebalanceProject_decorators = [write(() => 'Rebalance project')];
+            __esDecorate(this, null, _moveCard_decorators, { kind: "method", name: "moveCard", static: false, private: false, access: { has: obj => "moveCard" in obj, get: obj => obj.moveCard }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _rankByIndex_decorators, { kind: "method", name: "rankByIndex", static: false, private: false, access: { has: obj => "rankByIndex" in obj, get: obj => obj.rankByIndex }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _rankCard_decorators, { kind: "method", name: "rankCard", static: false, private: false, access: { has: obj => "rankCard" in obj, get: obj => obj.rankCard }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _rankFirst_decorators, { kind: "method", name: "rankFirst", static: false, private: false, access: { has: obj => "rankFirst" in obj, get: obj => obj.rankFirst }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _rebalanceChildren_decorators, { kind: "method", name: "rebalanceChildren", static: false, private: false, access: { has: obj => "rebalanceChildren" in obj, get: obj => obj.rebalanceChildren }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _rebalanceProject_decorators, { kind: "method", name: "rebalanceProject", static: false, private: false, access: { has: obj => "rebalanceProject" in obj, get: obj => obj.rebalanceProject }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        project = __runInitializers(this, _instanceExtraInitializers);
+        constructor(project) {
+            this.project = project;
+        }
+        // Returns children of a parent card or root cards
+        getSiblings(card) {
+            const parentCardKey = card.parent || ROOT;
+            // since we don't know if 'root' is templateRoot or cardRoot, we need to check the card
+            if (parentCardKey === ROOT) {
+                if (isTemplateCard(card)) {
+                    if (isModuleCard(card)) {
+                        throw new Error(`Cannot rank module cards`);
+                    }
+                    const { template } = cardPathParts(this.project.projectPrefix, card.path);
+                    return this.project.templateCards(template);
                 }
-                const { template } = cardPathParts(this.project.projectPrefix, card.path);
-                return this.project.templateCards(template);
             }
-        }
-        let parentCard;
-        if (parentCardKey !== ROOT) {
-            parentCard = this.project.findCard(parentCardKey);
-            return this.project.cardKeysToCards(parentCard.children);
-        }
-        return this.project
-            .showProjectCards()
-            .filter((item) => item.parent === 'root' || item.parent === '');
-    }
-    // Rebalances cards
-    async rebalanceCards(cards) {
-        const ranks = rebalanceRanks(cards.length);
-        cards = sortItems(cards, (item) => item.metadata?.rank || 'z');
-        for (let i = 0; i < cards.length; i++) {
-            const card = cards[i];
-            await this.project.updateCardMetadataKey(card.key, 'rank', ranks[i]);
-        }
-    }
-    // Rebalances the project recursively.
-    async rebalanceProjectRecursively(cards) {
-        const ranks = rebalanceRanks(cards.length);
-        cards = sortItems(cards, (item) => item.metadata?.rank || 'z');
-        for (let i = 0; i < cards.length; i++) {
-            const card = cards[i];
-            await this.project.updateCardMetadataKey(card.key, 'rank', ranks[i]);
-            if (card.children && card.children.length > 0) {
-                await this.rebalanceProjectRecursively(this.project.cardKeysToCards(card.children));
+            let parentCard;
+            if (parentCardKey !== ROOT) {
+                parentCard = this.project.findCard(parentCardKey);
+                return this.project.cardKeysToCards(parentCard.children);
             }
-        }
-    }
-    /**
-     * Moves card from 'destination' to 'source'.
-     * @param source source card to move
-     * @param destination destination card where source card will be moved to; or to root
-     */
-    async moveCard(source, destination) {
-        if (source === ROOT) {
-            throw new Error('Cannot move "root"');
-        }
-        if (source === destination) {
-            throw new Error(`Card cannot be moved to itself`);
-        }
-        const movingToRoot = destination === ROOT;
-        const sourceCard = this.project.findCard(source);
-        const destinationCard = !movingToRoot
-            ? this.project.findCard(destination)
-            : undefined;
-        // Prevent moving card to inside its descendants
-        if (destinationCard) {
-            const { parents } = cardPathParts(this.project.projectPrefix, destinationCard.path);
-            if (parents.includes(source)) {
-                throw new Error(`Card cannot be moved to inside itself`);
+            return this.project
+                .showProjectCards()
+                .filter((item) => item.parent === 'root' || item.parent === '');
+        }
+        // Rebalances cards
+        async rebalanceCards(cards) {
+            const ranks = rebalanceRanks(cards.length);
+            cards = sortItems(cards, (item) => item.metadata?.rank || 'z');
+            for (let i = 0; i < cards.length; i++) {
+                const card = cards[i];
+                await this.project.updateCardMetadataKey(card.key, 'rank', ranks[i]);
             }
         }
-        // Imported templates cannot be modified.
-        if ((destinationCard && isModuleCard(destinationCard)) ||
-            isModuleCard(sourceCard)) {
-            throw new Error(`Cannot modify imported module templates`);
-        }
-        // Special handling for moving to root
-        if (movingToRoot) {
-            if (isTemplateCard(sourceCard)) {
-                throw new Error(`Template cards cannot be moved to project root`);
+        // Rebalances the project recursively.
+        async rebalanceProjectRecursively(cards) {
+            const ranks = rebalanceRanks(cards.length);
+            cards = sortItems(cards, (item) => item.metadata?.rank || 'z');
+            for (let i = 0; i < cards.length; i++) {
+                const card = cards[i];
+                await this.project.updateCardMetadataKey(card.key, 'rank', ranks[i]);
+                if (card.children && card.children.length > 0) {
+                    await this.rebalanceProjectRecursively(this.project.cardKeysToCards(card.children));
+                }
             }
         }
-        else {
-            const bothTemplateCards = isTemplateCard(sourceCard) &&
-                destinationCard &&
-                isTemplateCard(destinationCard);
-            const bothProjectCards = this.project.hasProjectCard(sourceCard.key) &&
-                destinationCard &&
-                this.project.hasProjectCard(destinationCard.key);
-            if (!(bothTemplateCards || bothProjectCards)) {
-                throw new Error(`Cards cannot be moved from project to template or vice versa`);
+        /**
+         * Moves card from 'destination' to 'source'.
+         * @param source source card to move
+         * @param destination destination card where source card will be moved to; or to root
+         */
+        async moveCard(source, destination) {
+            if (source === ROOT) {
+                throw new Error('Cannot move "root"');
             }
-        }
-        const destinationPath = movingToRoot
-            ? join(this.project.paths.cardRootFolder, sourceCard.key)
-            : join(destinationCard.path, 'c', sourceCard.key);
-        // if the card is already in the destination, do nothing
-        if (sourceCard.path === destinationPath) {
-            return;
-        }
-        // if both are project cards, make sure source card can be moved
-        const actionGuard = new ActionGuard(this.project.calculationEngine);
-        await actionGuard.checkPermission('move', source);
-        // re-rank the card in the new location
-        // it will be the last one in the new location
-        let children;
-        if (!movingToRoot) {
-            const parent = this.project.findCard(destination);
-            children = this.project.cardKeysToCards(parent.children);
-        }
-        else {
-            children = this.project.showProjectCards();
-        }
-        if (!children) {
-            throw new Error(`Children not found from card ${destination}`);
-        }
-        children = sortItems(children, (item) => item?.metadata?.rank || '1|z');
-        const lastChild = children[children.length - 1];
-        const rank = lastChild && lastChild.metadata
-            ? getRankAfter(lastChild.metadata.rank)
-            : FIRST_RANK;
-        // First do the file operations, then update metadata
-        await copyDir(sourceCard.path, destinationPath);
-        await deleteDir(sourceCard.path);
-        // Update card with new path, parent, and rank
-        sourceCard.path = destinationPath;
-        sourceCard.parent = movingToRoot ? ROOT : destination;
-        if (sourceCard.metadata) {
-            sourceCard.metadata.rank = rank;
-        }
-        // Handle cache update and persistence
-        await this.project.updateCard(sourceCard);
-        const updatedCard = {
-            ...sourceCard,
-            path: destinationPath,
-            parent: movingToRoot ? ROOT : destination,
-            metadata: sourceCard.metadata
-                ? {
-                    ...sourceCard.metadata,
-                    rank: rank,
+            if (source === destination) {
+                throw new Error(`Card cannot be moved to itself`);
+            }
+            const movingToRoot = destination === ROOT;
+            const sourceCard = this.project.findCard(source);
+            const destinationCard = !movingToRoot
+                ? this.project.findCard(destination)
+                : undefined;
+            // Prevent moving card to inside its descendants
+            if (destinationCard) {
+                const { parents } = cardPathParts(this.project.projectPrefix, destinationCard.path);
+                if (parents.includes(source)) {
+                    throw new Error(`Card cannot be moved to inside itself`);
                 }
-                : undefined,
-        };
-        // Fetch old parent
-        const oldParent = sourceCard.parent;
-        let oldParentCard;
-        if (oldParent && oldParent !== ROOT) {
-            oldParentCard = this.project.findCard(oldParent);
-        }
-        let newParentCard;
-        if (!movingToRoot) {
-            newParentCard = this.project.findCard(destination);
-        }
-        // Finally, update the project
-        await this.project.handleCardMoved(updatedCard, newParentCard, oldParentCard);
-    }
-    /**
-     * Ranks card using position given as 'index'.
-     * @param cardKey card key
-     * @param index to which position should card be ranked to
-     */
-    async rankByIndex(cardKey, index) {
-        if (index < 0) {
-            throw new Error(`Index must be greater than 0`);
-        }
-        if (index === 0) {
-            await this.rankFirst(cardKey);
-            return;
-        }
-        const card = this.project.findCard(cardKey);
-        if (!card.parent) {
-            throw new Error(`Parent card ${cardKey} not found from project`);
-        }
-        const children = sortItems(this.getSiblings(card), (item) => item.metadata?.rank || EMPTY_RANK);
-        if (!children || children.length === 0) {
-            throw new Error(`Children not found from card ${card.parent}`);
-        }
-        if (children.length < index) {
-            throw new Error(`Index ${index} is out of bounds`);
-        }
-        await this.rankCard(cardKey, children[index - 1].key);
-    }
-    /**
-     * Sets the rank of a card to be after another card.
-     * @param cardKey Card to rank
-     * @param beforeCardKey Card key after which the card will be ranked
-     */
-    async rankCard(cardKey, beforeCardKey) {
-        const card = this.project.findCard(cardKey);
-        const beforeCard = this.project.findCard(beforeCardKey);
-        if (beforeCard.parent !== card.parent) {
-            throw new Error(`Cards must be from the same parent`);
-        }
-        const children = sortItems(this.getSiblings(beforeCard), (item) => item.metadata?.rank || EMPTY_RANK);
-        if (!children) {
-            throw new Error(`Children not found from card ${beforeCard.parent}`);
-        }
-        const beforeCardIndex = children.findIndex((child) => child.key === beforeCard.key);
-        if (beforeCardIndex === -1) {
-            throw new Error(`Card ${beforeCardKey} is not a child of ${beforeCard.parent}`);
-        }
-        if (children[beforeCardIndex].key === cardKey) {
-            throw new Error(`Card cannot be ranked after itself`);
-        }
-        if (beforeCardIndex === children.length - 1) {
-            await this.project.updateCardMetadataKey(cardKey, 'rank', getRankAfter(beforeCard.metadata?.rank));
-        }
-        else {
-            await this.project.updateCardMetadataKey(cardKey, 'rank', getRankBetween(beforeCard.metadata?.rank, children[beforeCardIndex + 1].metadata?.rank));
-        }
-    }
-    /**
-     * Ranks card first.
-     * @param cardKey card key
-     */
-    async rankFirst(cardKey) {
-        const card = this.project.findCard(cardKey);
-        const children = sortItems(this.getSiblings(card), (item) => item.metadata?.rank || EMPTY_RANK);
-        if (!children || children.length === 0) {
-            throw new Error(`Children not found from card ${card.parent}`);
-        }
-        if (children[0].key === cardKey && children[0].metadata?.rank) {
-            return;
-        }
-        const firstRank = children[0].metadata?.rank;
-        if (!firstRank) {
-            await this.project.updateCardMetadataKey(cardKey, 'rank', FIRST_RANK);
-            return;
-        }
-        // Set the rank to be the first one
-        if (firstRank === FIRST_RANK) {
-            // if the first card is already at the first rank, we need to move the card to the next one
-            const secondRank = children[1].metadata?.rank;
-            if (!secondRank) {
-                throw new Error(`Second rank not found`);
-            }
-            const rankBetween = getRankBetween(firstRank, secondRank);
-            await this.project.updateCardMetadataKey(children[0].key, 'rank', rankBetween);
-            await this.project.updateCardMetadataKey(cardKey, 'rank', firstRank);
-        }
-        else {
-            // if the card is not at the first rank, we just use the first rank
-            await this.project.updateCardMetadataKey(cardKey, 'rank', FIRST_RANK);
+            }
+            // Imported templates cannot be modified.
+            if ((destinationCard && isModuleCard(destinationCard)) ||
+                isModuleCard(sourceCard)) {
+                throw new Error(`Cannot modify imported module templates`);
+            }
+            // Special handling for moving to root
+            if (movingToRoot) {
+                if (isTemplateCard(sourceCard)) {
+                    throw new Error(`Template cards cannot be moved to project root`);
+                }
+            }
+            else {
+                const bothTemplateCards = isTemplateCard(sourceCard) &&
+                    destinationCard &&
+                    isTemplateCard(destinationCard);
+                const bothProjectCards = this.project.hasProjectCard(sourceCard.key) &&
+                    destinationCard &&
+                    this.project.hasProjectCard(destinationCard.key);
+                if (!(bothTemplateCards || bothProjectCards)) {
+                    throw new Error(`Cards cannot be moved from project to template or vice versa`);
+                }
+            }
+            const destinationPath = movingToRoot
+                ? join(this.project.paths.cardRootFolder, sourceCard.key)
+                : join(destinationCard.path, 'c', sourceCard.key);
+            // if the card is already in the destination, do nothing
+            if (sourceCard.path === destinationPath) {
+                return;
+            }
+            // if both are project cards, make sure source card can be moved
+            const actionGuard = new ActionGuard(this.project.calculationEngine);
+            await actionGuard.checkPermission('move', source);
+            // re-rank the card in the new location
+            // it will be the last one in the new location
+            let children;
+            if (!movingToRoot) {
+                const parent = this.project.findCard(destination);
+                children = this.project.cardKeysToCards(parent.children);
+            }
+            else {
+                children = this.project.showProjectCards();
+            }
+            if (!children) {
+                throw new Error(`Children not found from card ${destination}`);
+            }
+            children = sortItems(children, (item) => item?.metadata?.rank || '1|z');
+            const lastChild = children[children.length - 1];
+            const rank = lastChild && lastChild.metadata
+                ? getRankAfter(lastChild.metadata.rank)
+                : FIRST_RANK;
+            // Save old path before moving (needed to update descendant paths)
+            const oldPath = sourceCard.path;
+            // First do the file operations, then update metadata
+            await copyDir(sourceCard.path, destinationPath);
+            await deleteDir(sourceCard.path);
+            // Update card with new path, parent, and rank
+            sourceCard.path = destinationPath;
+            sourceCard.parent = movingToRoot ? ROOT : destination;
+            if (sourceCard.metadata) {
+                sourceCard.metadata.rank = rank;
+            }
+            // Update attachment paths for the moved card
+            if (sourceCard.attachments && sourceCard.attachments.length > 0) {
+                for (const attachment of sourceCard.attachments) {
+                    if (attachment.path.startsWith(oldPath)) {
+                        attachment.path = attachment.path.replace(oldPath, destinationPath);
+                    }
+                }
+            }
+            // Handle cache update and persistence
+            await this.project.updateCard(sourceCard);
+            // Update all descendant card paths in the cache to reflect the new filesystem location.
+            // This is critical: files have been moved on disk, but children's cached paths
+            // still point to the old location. Without this, operations on children
+            // (like edit or delete) would target non-existent paths, leaving orphaned files.
+            if (sourceCard.children && sourceCard.children.length > 0) {
+                for (const childKey of sourceCard.children) {
+                    this.project.updateDescendantPathsAfterMove(childKey, oldPath, destinationPath);
+                }
+            }
+            const updatedCard = {
+                ...sourceCard,
+                path: destinationPath,
+                parent: movingToRoot ? ROOT : destination,
+                metadata: sourceCard.metadata
+                    ? {
+                        ...sourceCard.metadata,
+                        rank: rank,
+                    }
+                    : undefined,
+            };
+            // Fetch old parent
+            const oldParent = sourceCard.parent;
+            let oldParentCard;
+            if (oldParent && oldParent !== ROOT) {
+                oldParentCard = this.project.findCard(oldParent);
+            }
+            let newParentCard;
+            if (!movingToRoot) {
+                newParentCard = this.project.findCard(destination);
+            }
+            // Finally, update the project
+            await this.project.handleCardMoved(updatedCard, newParentCard, oldParentCard);
+        }
+        /**
+         * Ranks card using position given as 'index'.
+         * @param cardKey card key
+         * @param index to which position should card be ranked to
+         */
+        async rankByIndex(cardKey, index) {
+            if (index < 0) {
+                throw new Error(`Index must be greater than 0`);
+            }
+            if (index === 0) {
+                await this.rankFirst(cardKey);
+                return;
+            }
+            const card = this.project.findCard(cardKey);
+            if (!card.parent) {
+                throw new Error(`Parent card ${cardKey} not found from project`);
+            }
+            const children = sortItems(this.getSiblings(card), (item) => item.metadata?.rank || EMPTY_RANK);
+            if (!children || children.length === 0) {
+                throw new Error(`Children not found from card ${card.parent}`);
+            }
+            if (children.length < index) {
+                throw new Error(`Index ${index} is out of bounds`);
+            }
+            await this.rankCard(cardKey, children[index - 1].key);
+        }
+        /**
+         * Sets the rank of a card to be after another card.
+         * @param cardKey Card to rank
+         * @param beforeCardKey Card key after which the card will be ranked
+         */
+        async rankCard(cardKey, beforeCardKey) {
+            const card = this.project.findCard(cardKey);
+            const beforeCard = this.project.findCard(beforeCardKey);
+            if (beforeCard.parent !== card.parent) {
+                throw new Error(`Cards must be from the same parent`);
+            }
+            const children = sortItems(this.getSiblings(beforeCard), (item) => item.metadata?.rank || EMPTY_RANK);
+            if (!children) {
+                throw new Error(`Children not found from card ${beforeCard.parent}`);
+            }
+            const beforeCardIndex = children.findIndex((child) => child.key === beforeCard.key);
+            if (beforeCardIndex === -1) {
+                throw new Error(`Card ${beforeCardKey} is not a child of ${beforeCard.parent}`);
+            }
+            if (children[beforeCardIndex].key === cardKey) {
+                throw new Error(`Card cannot be ranked after itself`);
+            }
+            if (beforeCardIndex === children.length - 1) {
+                await this.project.updateCardMetadataKey(cardKey, 'rank', getRankAfter(beforeCard.metadata?.rank));
+            }
+            else {
+                await this.project.updateCardMetadataKey(cardKey, 'rank', getRankBetween(beforeCard.metadata?.rank, children[beforeCardIndex + 1].metadata?.rank));
+            }
         }
-    }
-    /**
-     *  Rebalances the ranks of the children of a card.
-     * @param parentCardKey parent card key
-     */
-    async rebalanceChildren(parentCardKey) {
-        const parentCard = this.project.findCard(parentCardKey);
-        if (!parentCard || !parentCard.children) {
-            throw new Error(`Card ${parentCardKey} not found from project`);
+        /**
+         * Ranks card first.
+         * @param cardKey card key
+         */
+        async rankFirst(cardKey) {
+            const card = this.project.findCard(cardKey);
+            const children = sortItems(this.getSiblings(card), (item) => item.metadata?.rank || EMPTY_RANK);
+            if (!children || children.length === 0) {
+                throw new Error(`Children not found from card ${card.parent}`);
+            }
+            if (children[0].key === cardKey && children[0].metadata?.rank) {
+                return;
+            }
+            const firstRank = children[0].metadata?.rank;
+            if (!firstRank) {
+                await this.project.updateCardMetadataKey(cardKey, 'rank', FIRST_RANK);
+                return;
+            }
+            // Set the rank to be the first one
+            if (firstRank === FIRST_RANK) {
+                // if the first card is already at the first rank, we need to move the card to the next one
+                const secondRank = children[1].metadata?.rank;
+                if (!secondRank) {
+                    throw new Error(`Second rank not found`);
+                }
+                const rankBetween = getRankBetween(firstRank, secondRank);
+                await this.project.updateCardMetadataKey(children[0].key, 'rank', rankBetween);
+                await this.project.updateCardMetadataKey(cardKey, 'rank', firstRank);
+            }
+            else {
+                // if the card is not at the first rank, we just use the first rank
+                await this.project.updateCardMetadataKey(cardKey, 'rank', FIRST_RANK);
+            }
         }
-        await this.rebalanceCards(this.project.cardKeysToCards(parentCard.children));
-    }
-    /**
-     * Rebalances the ranks of the cards in the whole project, including templates
-     * Can be used even if the ranks do not exist
-     */
-    async rebalanceProject() {
-        const cards = this.project.showProjectCards();
-        await this.rebalanceProjectRecursively(cards);
-        const templateCards = this.project.allTemplateCards();
-        const cardGroups = templateCards.reduce((result, card) => {
-            // template card root cards always have a parent(, thus this shouldn't happen
-            if (!card.parent) {
-                return result;
+        /**
+         *  Rebalances the ranks of the children of a card.
+         * @param parentCardKey parent card key
+         */
+        async rebalanceChildren(parentCardKey) {
+            const parentCard = this.project.findCard(parentCardKey);
+            if (!parentCard || !parentCard.children) {
+                throw new Error(`Card ${parentCardKey} not found from project`);
             }
-            if (!result[card.parent]) {
-                result[card.parent] = [];
+            await this.rebalanceCards(this.project.cardKeysToCards(parentCard.children));
+        }
+        /**
+         * Rebalances the ranks of the cards in the whole project, including templates
+         * Can be used even if the ranks do not exist
+         */
+        async rebalanceProject() {
+            const cards = this.project.showProjectCards();
+            await this.rebalanceProjectRecursively(cards);
+            const templateCards = this.project.allTemplateCards();
+            const cardGroups = templateCards.reduce((result, card) => {
+                // template card root cards always have a parent(, thus this shouldn't happen
+                if (!card.parent) {
+                    return result;
+                }
+                if (!result[card.parent]) {
+                    result[card.parent] = [];
+                }
+                result[card.parent].push(card);
+                return result;
+            }, {});
+            for (const [, cards] of Object.entries(cardGroups)) {
+                await this.rebalanceCards(cards);
             }
-            result[card.parent].push(card);
-            return result;
-        }, {});
-        for (const [, cards] of Object.entries(cardGroups)) {
-            await this.rebalanceCards(cards);
         }
-    }
-}
+    };
+})();
+export { Move };
 //# sourceMappingURL=move.js.map