ftreeview 0.1.1

package/src/lib/changeStatus.js

@@ -0,0 +1,79 @@
+/**
+ * Shared helpers for added/modified visual status indicators.
+ * Status values are intentionally limited to:
+ * - '' (no indicator)
+ * - 'A' (added)
+ * - 'M' (modified)
+ */
+
+export const CHANGE_STATUS = {
+  ADDED: 'A',
+  MODIFIED: 'M',
+};
+
+/**
+ * Normalize any input into a supported change status.
+ *
+ * @param {string} status - Raw status value
+ * @returns {''|'A'|'M'} Normalized status
+ */
+export function normalizeChangeStatus(status = '') {
+  if (status === CHANGE_STATUS.MODIFIED) {
+    return CHANGE_STATUS.MODIFIED;
+  }
+  if (status === CHANGE_STATUS.ADDED) {
+    return CHANGE_STATUS.ADDED;
+  }
+  return '';
+}
+
+/**
+ * Merge two statuses with priority: M > A > clean.
+ *
+ * @param {string} first - First status
+ * @param {string} second - Second status
+ * @returns {''|'A'|'M'} Merged status
+ */
+export function mergeChangeStatus(first = '', second = '') {
+  const left = normalizeChangeStatus(first);
+  const right = normalizeChangeStatus(second);
+
+  if (left === CHANGE_STATUS.MODIFIED || right === CHANGE_STATUS.MODIFIED) {
+    return CHANGE_STATUS.MODIFIED;
+  }
+  if (left === CHANGE_STATUS.ADDED || right === CHANGE_STATUS.ADDED) {
+    return CHANGE_STATUS.ADDED;
+  }
+  return '';
+}
+
+/**
+ * Convert git status into a change indicator status.
+ * Only A/M are considered valid for this indicator.
+ *
+ * @param {string} gitStatus - Single-character git status
+ * @returns {''|'A'|'M'} Indicator status
+ */
+export function mapGitStatusToChangeStatus(gitStatus = '') {
+  // Treat "untracked" as "added" for the A/M indicator so new files show up.
+  if (gitStatus === 'U') {
+    return CHANGE_STATUS.ADDED;
+  }
+  return normalizeChangeStatus(gitStatus);
+}
+
+/**
+ * Convert chokidar watcher event into a change indicator status.
+ *
+ * @param {string} event - Chokidar event name
+ * @returns {''|'A'|'M'} Indicator status
+ */
+export function mapWatcherEventToChangeStatus(event = '') {
+  if (event === 'add' || event === 'addDir') {
+    return CHANGE_STATUS.ADDED;
+  }
+  if (event === 'change') {
+    return CHANGE_STATUS.MODIFIED;
+  }
+  return '';
+}

package/src/lib/connectors.js

@@ -0,0 +1,233 @@
+/**
+ * Tree Connector Logic for ftree
+ *
+ * Generates the prefix strings for tree visualization using box-drawing characters.
+ * Handles nested directory structures with proper continuation lines.
+ */
+
+/**
+ * Box-drawing characters for tree connectors
+ */
+const CONNECTORS = {
+  /** Middle child connector: "├── " */
+  MIDDLE: '├── ',
+
+  /** Last child connector: "└── " */
+  LAST: '└── ',
+
+  /** Vertical continuation for parents: "│   " */
+  VERTICAL: '│   ',
+
+  /** Empty space (no continuation): "    " */
+  EMPTY: '    ',
+};
+
+/**
+ * Computes the prefix string for a tree node based on its position in the tree.
+ *
+ * The prefix consists of 4-character segments for each level of depth:
+ * - For levels above the current: vertical continuation if the ancestor is not a last child
+ * - For the current level: middle or last connector (or nothing for root)
+ *
+ * @param {object} node - Current FileNode with depth property
+ * @param {boolean} isLast - True if this node is the last child of its parent
+ * @param {boolean[]} parentPrefixes - Array indicating if each ancestor is a last child
+ * @returns {string} The complete prefix string for this node
+ *
+ * @example
+ * // Root node (depth 0)
+ * getPrefix({ depth: 0 }, false, [])
+ * // => ""
+ *
+ * // Depth 1, middle child
+ * getPrefix({ depth: 1 }, false, [])
+ * // => "├── "
+ *
+ * // Depth 1, last child
+ * getPrefix({ depth: 1 }, true, [])
+ * // => "└── "
+ *
+ * // Depth 2, under a middle parent
+ * getPrefix({ depth: 2 }, false, [false])
+ * // => "│   ├── "
+ *
+ * // Depth 2, under a last parent
+ * getPrefix({ depth: 2 }, true, [true])
+ * // => "    └── "
+ *
+ * // Depth 3, complex case
+ * getPrefix({ depth: 3 }, false, [false, true])
+ * // => "│       ├── "
+ */
+export function getPrefix(node, isLast, parentPrefixes) {
+  if (!node || node.depth === 0) {
+    return '';
+  }
+
+  const segments = [];
+
+  // Build prefix segments for each ancestor level
+  for (let level = 0; level < node.depth; level++) {
+    if (level === node.depth - 1) {
+      // Current level: use middle or last connector
+      segments.push(isLast ? CONNECTORS.LAST : CONNECTORS.MIDDLE);
+    } else {
+      // Parent level: vertical continuation if not last child, empty otherwise
+      const ancestorIsLast = parentPrefixes[level] || false;
+      segments.push(ancestorIsLast ? CONNECTORS.EMPTY : CONNECTORS.VERTICAL);
+    }
+  }
+
+  return segments.join('');
+}
+
+/**
+ * Computes which ancestors are "last children" for a given node in the flattened list.
+ *
+ * This function walks up the tree structure by examining parent relationships
+ * in the original hierarchical tree to determine the prefix continuation pattern.
+ *
+ * @param {object[]} flatList - Flattened list of FileNodes from flattenTree()
+ * @param {number} index - Index of the current node in the flattened list
+ * @returns {boolean[]} Array where each index indicates if the ancestor at that level is a last child
+ *
+ * @example
+ * // Given a tree structure:
+ * // root/
+ * // ├── src/
+ * // │   ├── utils.js
+ * // │   └── helper.js  <-- index points here
+ * // └── tests/
+ *
+ * // For helper.js:
+ * // parent (src) is not last (tests comes after)
+ * // root is... (need to check if src is root's last child)
+ * computeAncestorPrefixes(flatList, indexOfHelperJs)
+ * // => [false] indicates src is not a last child
+ *
+ * @example
+ * // For a deeply nested node:
+ * // root/
+ * // └── src/
+ * //     └── lib/
+ * //         └── core.js  <-- index points here
+ * // Returns: [true, true] - both src and lib are last children
+ */
+export function computeAncestorPrefixes(flatList, index) {
+  if (!flatList || index < 0 || index >= flatList.length) {
+    return [];
+  }
+
+  const currentNode = flatList[index];
+  const ancestorIsLast = [];
+
+  // For each ancestor level (from direct parent up to root-adjacent),
+  // determine if that ancestor is a last child of its parent.
+  // We iterate (currentNode.depth - 1) times because:
+  // - depth 0 node: no ancestors
+  // - depth 1 node: 1 ancestor at index 0 (the root)
+  // - depth 2 node: 2 ancestors (root, parent)
+  let targetNode = currentNode;
+  let targetIndex = index;
+
+  for (let level = 0; level < currentNode.depth; level++) {
+    const parentInfo = findParentInfo(flatList, targetIndex, targetNode.depth);
+
+    if (!parentInfo) {
+      // Reached root's parent or invalid tree structure
+      break;
+    }
+
+    // Stop if we've reached root (depth 0) - we only care about ancestors of root
+    if (parentInfo.node.depth === 0) {
+      break;
+    }
+
+    // Check if the parent node is a last child
+    const isParentLast = isLastChild(flatList, parentInfo.index);
+
+    ancestorIsLast.push(isParentLast);
+
+    // Move up to the parent for next iteration
+    targetNode = parentInfo.node;
+    targetIndex = parentInfo.index;
+  }
+
+  // The array is built from direct parent to root-adjacent,
+  // so reverse it to get root-adjacent to direct parent order.
+  // Example: for node at depth 3 under [root(not last), parent(last)]
+  // we want [false, true] not [true, false]
+  return ancestorIsLast.reverse();
+}
+
+/**
+ * Finds the parent node and its index in the flattened list.
+ *
+ * @param {object[]} flatList - Flattened list of FileNodes
+ * @param {number} childIndex - Index of the child node
+ * @param {number} childDepth - Depth of the child node
+ * @returns {{node: object, index: number}|null} Parent info or null if not found
+ */
+function findParentInfo(flatList, childIndex, childDepth) {
+  if (childDepth === 0) {
+    return null;
+  }
+
+  // Parent has depth = childDepth - 1
+  // Search backwards from childIndex to find the parent
+  for (let i = childIndex - 1; i >= 0; i--) {
+    const node = flatList[i];
+    if (node.depth === childDepth - 1) {
+      return { node, index: i };
+    }
+    // If we've gone to a shallower depth, we've passed the parent
+    if (node.depth < childDepth - 1) {
+      break;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Determines if a node at the given index is a last child of its parent.
+ *
+ * A node is a last child if there are no siblings following it in the
+ * flattened list before the depth decreases (indicating we've moved to
+ * a different parent).
+ *
+ * @param {object[]} flatList - Flattened list of FileNodes
+ * @param {number} index - Index of the node to check
+ * @returns {boolean} True if this node is the last child of its parent
+ */
+function isLastChild(flatList, index) {
+  if (index >= flatList.length - 1) {
+    return true;
+  }
+
+  const currentNode = flatList[index];
+  const nextNode = flatList[index + 1];
+
+  // If next node is shallower or at same depth (not a child), this is a last child
+  // If next node is deeper (a child), this is NOT a last child
+  return nextNode.depth <= currentNode.depth;
+}
+
+/**
+ * Computes ancestor prefixes for all nodes in a flattened list.
+ * Useful for batch processing in TreeView component.
+ *
+ * @param {object[]} flatList - Flattened list of FileNodes from flattenTree()
+ * @returns {Map<number, boolean[]>} Map from node index to ancestor prefix array
+ */
+export function computeAllPrefixes(flatList) {
+  const prefixesMap = new Map();
+
+  for (let i = 0; i < flatList.length; i++) {
+    prefixesMap.set(i, computeAncestorPrefixes(flatList, i));
+  }
+
+  return prefixesMap;
+}
+
+export { CONNECTORS };

package/src/lib/constants.js

@@ -0,0 +1,64 @@
+/**
+ * Default configuration values for ftree
+ */
+
+export const DEFAULT_CONFIG = {
+  /** Maximum depth to traverse the directory tree */
+  maxDepth: 10,
+
+  /** Show hidden files (starting with .) */
+  showHidden: false,
+
+  /** Show ignored files (--no-ignore flag) */
+  showIgnored: false,
+
+  /** Files/directories to ignore (gitignore-style patterns) */
+  ignorePatterns: [
+    'node_modules/**',
+    '.git/**',
+    'dist/**',
+    'build/**',
+    '*.log',
+  ],
+
+  /** Watch for file system changes and update tree */
+  watch: true,
+
+  /** Show git status (modified, added, deleted, untracked files) */
+  showGitStatus: true,
+
+  /** Number of concurrent file system operations */
+  concurrency: 50,
+
+  /** Update interval for git status (ms) */
+  gitStatusInterval: 2000,
+
+  /** Debounce delay for file system events (ms) */
+  debounceDelay: 100,
+};
+
+export const GIT_STATUS = {
+  /** Modified but not staged */
+  MODIFIED: 'M',
+
+  /** Staged for commit */
+  STAGED: 'A',
+
+  /** Deleted but not staged */
+  DELETED: 'D',
+
+  /** Untracked files */
+  UNTRACKED: '?',
+
+  /** Renamed */
+  RENAMED: 'R',
+
+  /** Conflicted */
+  CONFLICTED: 'C',
+};
+
+export const FILE_TYPE = {
+  DIRECTORY: 'directory',
+  FILE: 'file',
+  SYMLINK: 'symlink',
+};