imdone-core 2.0.0 → 2.0.1

package/lib/tools.js

@@ -0,0 +1,176 @@
+import _isFunction from 'lodash.isfunction'
+import _noop from 'lodash.noop'
+import crypto from 'crypto'
+import _path from 'path'
+import { sort } from 'fast-sort'
+import eol from 'eol'
+import escapeRegExp from 'escape-string-regexp'
+
+const max_bytes = 512
+
+function isBinaryCheck(bytes, size) {
+  if (size === 0) return false
+
+  var suspicious_bytes = 0
+  var total_bytes = Math.min(size, max_bytes)
+
+  if (size >= 3 && bytes[0] == 0xef && bytes[1] == 0xbb && bytes[2] == 0xbf) {
+    // UTF-8 BOM. This isn't binary.
+    return false
+  }
+
+  for (var i = 0; i < total_bytes; i++) {
+    if (bytes[i] === 0) {
+      // NULL byte--it's binary!
+      return true
+    } else if (
+      (bytes[i] < 7 || bytes[i] > 14) &&
+      (bytes[i] < 32 || bytes[i] > 127)
+    ) {
+      // UTF-8 detection
+      if (bytes[i] > 191 && bytes[i] < 224 && i + 1 < total_bytes) {
+        i++
+        if (bytes[i] < 192) {
+          continue
+        }
+      } else if (bytes[i] > 223 && bytes[i] < 239 && i + 2 < total_bytes) {
+        i++
+        if (bytes[i] < 192 && bytes[i + 1] < 192) {
+          i++
+          continue
+        }
+      }
+      suspicious_bytes++
+      // Read at least 32 bytes before making a decision
+      if (i > 32 && (suspicious_bytes * 100) / total_bytes > 10) {
+        return true
+      }
+    }
+  }
+
+  if ((suspicious_bytes * 100) / total_bytes > 10) {
+    return true
+  }
+
+  return false
+}
+
+function deepEqual(a, b) {
+  if (a === b) return true; // Same reference
+
+  if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null) {
+    return false; // Different types or one is null
+  }
+
+  if (Array.isArray(a) !== Array.isArray(b)) return false; // One is array, one is object
+
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false; // Different number of keys
+
+  return keysA.every((key) => keysB.includes(key) && deepEqual(a[key], b[key]));
+}
+
+export const tools =  {
+  union(...arrays) {
+    return [...new Set(arrays.flat())];
+  },
+  escapeRegExp(str) {
+    return escapeRegExp(str)
+  },
+  userHome() {
+    return process.env.HOME || process.env.HOMEPATH || process.env.USERPROFILE
+  },
+  deepEqual,
+  /**
+   * Description
+   * @method user
+   * @return LogicalExpression
+   */
+  user() {
+    return process.env.USER || process.env.USERNAME
+  },
+
+  /**
+   * Description
+   * @method cb
+   * @param {} cb
+   * @return ConditionalExpression
+   */
+  cb(cb) {
+    return _isFunction(cb) ? cb : _noop
+  },
+
+  inMixinsNoop(cb) {
+    cb = this.cb(cb)
+    if (cb) return cb(new Error('Implemented in mixins'))
+    throw new Error('Implemented in mixins')
+  },
+
+  /**
+   * Description
+   * @method sha
+   * @param {} data
+   * @return CallExpression
+   */
+  sha: function (data) {
+    var shasum = crypto.createHash('sha1')
+    shasum.update(data)
+    return shasum.digest('hex')
+  },
+
+  /**
+   * Description
+   * @method format
+   * @param {} template
+   * @param {} col
+   * @return CallExpression
+   */
+  format: function (template, col) {
+    col =
+      typeof col === 'object' ? col : Array.prototype.slice.call(arguments, 2)
+
+    return template.replace(/\{\{|\}\}|\{(\w+)\}/g, function (m, n) {
+      if (m == '{{') {
+        return '{'
+      }
+      if (m == '}}') {
+        return '}'
+      }
+      return col[n]
+    })
+  },
+
+  isBinaryFile: function (fs, file, callback) {
+    fs.exists(file, function (exists) {
+      if (!exists) return callback(null, false)
+
+      fs.open(file, 'r', function (err, descriptor) {
+        if (err) return callback(err)
+        var bytes = new Buffer(max_bytes)
+        // Read the file with no encoding for raw buffer access.
+        fs.read(
+          descriptor,
+          bytes,
+          0,
+          bytes.length,
+          0,
+          function (err, size, bytes) {
+            fs.close(descriptor, function (err2) {
+              if (err || err2) return callback(err || err2)
+              return callback(null, isBinaryCheck(bytes, size))
+            })
+          }
+        )
+      })
+    })
+  },
+
+  isBinaryCheck: isBinaryCheck,
+  sortTasks(tasks) {
+    return sort(tasks).asc([u => u.order, u => u.text])
+  },
+  hasBlankLines(content) {
+    return new RegExp(`^\\s*${String(eol.auto)}`, 'gm').test(content)
+  },
+}

package/lib/usecases/actions.js

@@ -0,0 +1,32 @@
+import { createFileSystemProject } from '../project-factory.js';
+import { load } from '../adapters/storage/config.js';
+import { logger } from '../adapters/logger.js';
+
+/**
+ * Initializes and returns a project instance.
+ * @param {string} projectPath - The path to the project.
+ * @param {string} configPath - The path to the configuration file.
+ * @returns {Promise<Object>} - The initialized project instance.
+ */
+async function initializeProject(projectPath, configPath) {
+  const path = projectPath;
+  const config = await load(projectPath, configPath);
+  const project = createFileSystemProject({ path, config });
+  await project.init();
+  await project.toImdoneJSON();
+
+  return project;
+}
+
+export async function executeBoardAction({ projectPath, configPath, task, action }) {
+  const project = await initializeProject(projectPath, configPath);
+  const file = task && project.getFile(task.filePath);
+  const activeTask = file && task.line > -1 && file.getTaskAtLine(task.line);
+  await project.performBoardAction(action, activeTask);
+}
+
+export async function listAvailableActions(projectPath, configPath, plugin) {
+  const project = await initializeProject(projectPath, configPath);
+  logger.log('\nAvailable actions:');
+  logger.log(JSON.stringify(project.boardActions, null, 2));
+}

package/lib/usecases/get-imdone-url.js

@@ -0,0 +1,6 @@
+// TODO Add a function that returns the imdone url for vscode and obsidian plugins
+// <!--
+// created:2025-01-11T20:20:08.348Z
+// sid:wmr_a0ikOY39kInkmudPa
+// order:-110
+// -->

package/lib/usecases/get-project-tags.js

@@ -0,0 +1,7 @@
+import { load } from '../adapters/storage/tags.js'
+import { findImdonePath } from '../adapters/storage/config.js'
+
+export async function getTags(filePath) {
+  const projectPath = await findImdonePath(filePath)
+  return await load(projectPath)
+}

package/lib/usecases/get-tasks-in-file.js

@@ -0,0 +1,26 @@
+import { loadForFilePath } from '../adapters/storage/config.js';
+import { getFileParser } from '../adapters/parsers/file/LocalFileParserFactory.js';
+import { Readable } from 'node:stream';
+
+
+export async function getTasks({filePath, content}) {
+  const config = await loadForFilePath(filePath)
+
+  const readStream = new Readable({
+    read() {
+      this.push(content);
+      this.push(null);
+    }
+  });
+
+  const parser = await getFileParser(filePath, config, readStream)
+
+  const tasks = []
+  let task = true
+  while (task) {
+    task = await parser.readTask()
+    if (task) tasks.push(task)
+  }
+  parser.close()
+  return tasks
+}

package/lib/usecases/index.js

@@ -0,0 +1,4 @@
+export * from './actions.js';
+export * from './get-imdone-url.js';
+export * from './get-project-tags.js';
+export * from './get-tasks-in-file.js';

package/package.json

@@ -1,23 +1,19 @@
 {
   "name": "imdone-core",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "imdone-core",
   "repository": {
     "type": "git",
     "url": "https://github.com/imdone/imdone-core.git"
   },
   "main": "lib/index.js",
-  "module": "lib/index.js",
   "types": "types/index.d.ts",
-  "files": [
-    "dist"
-  ],
   "type": "module",
   "bin": {
     "imdone-cli": "lib/cli.js"
   },
   "scripts": {
-    "prepublishOnly": "npm run build:index && npm run build",
+    "prepublishOnly": "npm run build",
     "build": "npm run build:docs && npm run build:docs:index && npm run coverage && npm run build:index && npm run build:types",
     "build:docs": "doctoc --github --notitle README.md",
     "build:docs:index": "node scripts/index-markdown.js",

package/scripts/delete-markdown-indexes.js

@@ -0,0 +1,87 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+// Get the current directory name in ESM
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const sidebar = '_index.md';
+
+function getMarkdownFiles(files = []) {
+  return files.filter(file => file.endsWith('.md') && file !== sidebar && file !== '_navbar.md');
+}
+
+function getFileLinks(files) {
+  return files.map(file => `- [${file.replace('.md', '')}](${file})`).join('\n');
+}
+
+function getSubDirLinks(files, directory) {
+  const subDirs = files.filter(file => fs.statSync(path.join(directory, file)).isDirectory());
+  const subDirsContainingMarkdown = subDirs.filter(subDir => fs.readdirSync(path.join(directory, subDir)).find(file => file.endsWith('.md')));
+  return subDirsContainingMarkdown.map(subDir => {
+    const resource = fs.readdirSync(path.join(directory, subDir)).find(file => file.toLowerCase() === 'readme.md')
+      ? 'README'
+      : sidebar;
+    return `- [:file_folder: **${subDir}**](${subDir}/${resource})`;
+  }).join('\n');
+}
+
+function getBreadCrumb(parentDir) {
+  const homeLink = '[:house: **Home**](/README)';
+  return parentDir ? `- ${homeLink}\n- [:arrow_heading_up: **Parent Directory**](${parentDir}${sidebar})` : '';
+}
+
+function createIndexes(directory, parentDir, title) {
+  const basename = path.basename(directory);
+  if (basename.startsWith('.')) {
+    return;
+  }
+
+  title = title || basename;
+
+  const files = fs.readdirSync(directory);
+  const markdownFiles = getMarkdownFiles(files);
+
+  if (markdownFiles.length > 0) {
+    const subDirLinks = getSubDirLinks(files, directory);
+    const fileLinks = getFileLinks(markdownFiles);
+    const breadcrumb = getBreadCrumb(parentDir);
+
+    fs.writeFileSync(path.join(directory, sidebar), `# ${title}\n${breadcrumb}\n${subDirLinks}\n${fileLinks}\n`);
+  }
+
+  files
+    .filter(file => fs.statSync(path.join(directory, file)).isDirectory())
+    .forEach(subDir => createIndexes(path.join(directory, subDir), parentDir ? path.join(parentDir, basename) + '/' : '/'));
+}
+
+createIndexes(process.cwd(), undefined, 'imdone-core');
+console.log('Indexes created successfully!');
+
+function deleteIndexFiles(dir) {
+  // Read the directory and filter for _index.md files
+  const files = fs.readdirSync(dir);
+
+  files.forEach(file => {
+    const filePath = path.join(dir, file);
+    const stat = fs.statSync(filePath);
+
+    // If it's a file and matches the _index.md pattern, delete it
+    if (stat.isFile() && file === '_index.md') {
+      console.log(`Deleting file: ${filePath}`);
+      fs.unlinkSync(filePath);
+    }
+
+    // If it's a directory, recurse
+    if (stat.isDirectory()) {
+      deleteIndexFiles(filePath);
+    }
+  });
+}
+
+// Path to your test directory
+const testDirectory = path.join(__dirname, '..', 'test');
+
+// Call the function to delete _index.md files
+deleteIndexFiles(testDirectory);

package/scripts/generate-index.js

@@ -0,0 +1,35 @@
+import fs from 'fs';
+import path from 'path';
+
+const LIB_DIR = './lib';
+
+// Recursively generates index.js files
+function generateIndexes(dir) {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+  const files = entries
+    .filter(entry => entry.isFile() && entry.name !== 'index.js' && entry.name !== 'cli.js' && entry.name.endsWith('.js'))
+    .map(entry => `export * from './${entry.name}';`);
+
+  const subdirs = entries
+    .filter(entry => entry.isDirectory() && entry.name !== '__tests__')
+    .map(entry => entry.name);
+
+  // Generate index.js in each subdirectory
+  subdirs.forEach(subdir => generateIndexes(path.join(dir, subdir)));
+
+  // Add namespace exports for subdirectories
+  const namespaceExports = subdirs.map(subdir => `export * as ${subdir} from './${subdir}/index.js';`);
+
+  // Write the index.js file
+  if (files.length || namespaceExports.length) {
+    const indexPath = path.join(dir, 'index.js');
+    const content = [...files, ...namespaceExports].join('\n') + '\n';
+    fs.writeFileSync(indexPath, content);
+    console.log(`Generated: ${indexPath}`);
+  }
+}
+
+// Run the script
+generateIndexes(LIB_DIR);
+console.log('✅ Index files generated successfully!');

package/scripts/index-markdown.js

@@ -0,0 +1,55 @@
+import fs from 'fs';
+import path from 'path';
+
+const sidebar = '_index.md';
+
+function getMarkdownFiles(files = []) {
+  return files.filter(file => file.endsWith('.md') && file !== sidebar && file !== '_navbar.md');
+}
+
+function getFileLinks(files) {
+  return files.map(file => `- [${file.replace('.md', '')}](${file})`).join('\n');
+}
+
+function getSubDirLinks(files, directory) {
+  const subDirs = files.filter(file => fs.statSync(path.join(directory, file)).isDirectory());
+  const subDirsContainingMarkdown = subDirs.filter(subDir => fs.readdirSync(path.join(directory, subDir)).find(file => file.endsWith('.md')));
+  return subDirsContainingMarkdown.map(subDir => {
+    const resource = fs.readdirSync(path.join(directory, subDir)).find(file => file.toLowerCase() === 'readme.md')
+      ? 'README'
+      : sidebar;
+    return `- [:file_folder: **${subDir}**](${subDir}/${resource})`;
+  }).join('\n');
+}
+
+function getBreadCrumb(parentDir) {
+  const homeLink = '[:house: **Home**](/README)';
+  return parentDir ? `- ${homeLink}\n- [:arrow_heading_up: **Parent Directory**](${parentDir}${sidebar})` : '';
+}
+
+function createIndexes(directory, parentDir, title) {
+  const basename = path.basename(directory);
+  if (basename.startsWith('.') || basename === 'test') {
+    return;
+  }
+
+  title = title || basename;
+
+  const files = fs.readdirSync(directory);
+  const markdownFiles = getMarkdownFiles(files);
+
+  if (markdownFiles.length > 0) {
+    const subDirLinks = getSubDirLinks(files, directory);
+    const fileLinks = getFileLinks(markdownFiles);
+    const breadcrumb = getBreadCrumb(parentDir);
+
+    fs.writeFileSync(path.join(directory, sidebar), `# ${title}\n${breadcrumb}\n${subDirLinks}\n${fileLinks}\n`);
+  }
+
+  files
+    .filter(file => fs.statSync(path.join(directory, file)).isDirectory())
+    .forEach(subDir => createIndexes(path.join(directory, subDir), parentDir ? path.join(parentDir, basename) + '/' : '/'));
+}
+
+createIndexes(process.cwd(), undefined, 'imdone-core');
+console.log('Indexes created successfully!');

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "declaration": true,
+    "emitDeclarationOnly": true,
+    "allowJs": true,
+    "outDir": "types",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "target": "ESNext",
+    "esModuleInterop": true,
+    "strict": true
+  },
+  "include": ["lib/**/index.js"],
+  "exclude": ["node_modules", "__tests__"]
+}

package/types/FileProjectContext.d.ts

@@ -0,0 +1,4 @@
+export class FileProjectContext {
+    getOrder(list: any, order: any): number | undefined;
+    getProject(): void;
+}

package/types/ProjectContext.d.ts

@@ -0,0 +1,9 @@
+export class ProjectContext extends FileProjectContext {
+    constructor(repo: any);
+    repo: any;
+    getOrder(list: any, order: any): any;
+    get config(): any;
+    toJSON(): null;
+    determineOrder(config: any, order: any, tasks: any): any;
+}
+import { FileProjectContext } from './FileProjectContext.js';

package/types/adapters/date-time.d.ts

@@ -0,0 +1,2 @@
+export function setNoDST(noDST: any): void;
+export function getIsoDateWithOffset(date: any): string;

package/types/adapters/environment.d.ts

@@ -0,0 +1 @@
+export function isDev(): boolean;

package/types/adapters/file-gateway.d.ts

@@ -0,0 +1,51 @@
+export function exists(path: any): Promise<false | _fs.Stats>;
+export function statSync(path: any): _fs.Stats | undefined;
+export function init(fileSystem?: typeof _fs): void;
+export function existsSync(...args: any[]): boolean;
+export function readFileSync(...args: any[]): string | Buffer<ArrayBufferLike>;
+export function appendFileSync(...args: any[]): void;
+export function writeFileSync(...args: any[]): void;
+export function readdir(...args: any[]): Promise<_fs.Dirent[]>;
+export function unlinkSync(...args: any[]): void;
+export function readdirSyncRecursive(path: any): any[];
+export function readdirSync(path: any): _fs.Dirent[];
+export function sanitizeFileName(fileName: any, replaceSpacesWith: any): any;
+export function preparePathForWriting(path: any, directory?: boolean): Promise<{
+    isFile: any;
+    isDirectory: any;
+}>;
+export function cp(src: any, dest: any, opts: any): Promise<void>;
+export function rm(path: any, opts: any): Promise<void>;
+export const sep: "/" | "\\";
+export const stat: typeof _fs.promises.stat;
+export const lstat: typeof _fs.promises.lstat;
+export const lstatSync: _fs.StatSyncFn;
+export const writeFile: typeof _fs.promises.writeFile;
+export const unlink: typeof _fs.promises.unlink;
+export const mkdir: typeof _fs.promises.mkdir;
+export const readFile: typeof _fs.promises.readFile;
+declare namespace _default {
+    export { cp };
+    export { rm };
+    export { exists };
+    export { stat };
+    export { lstat };
+    export { lstatSync };
+    export { readFileSync };
+    export { appendFileSync };
+    export { writeFileSync };
+    export { writeFile };
+    export { readdir };
+    export { unlink };
+    export { mkdir };
+    export { readFile };
+    export { readdirSyncRecursive };
+    export { readdirSync };
+    export { sanitizeFileName };
+    export { preparePathForWriting };
+    export { unlinkSync };
+    export { existsSync };
+    export { sep };
+}
+export default _default;
+import _fs from 'fs';

package/types/adapters/git-download.d.ts

@@ -0,0 +1 @@
+export function downloadPlugin(repo: any, dest: any): Promise<void>;

package/types/adapters/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./date-time.js";
+export * from "./environment.js";
+export * from "./file-gateway.js";
+export * from "./git-download.js";
+export * from "./logger.js";
+export * from "./markdown.js";
+export * from "./yaml.js";
+export * as parsers from "./parsers/index.js";
+export * as storage from "./storage/index.js";

package/types/adapters/logger.d.ts

@@ -0,0 +1,24 @@
+export const logger: Logger;
+declare class Logger {
+    level: number;
+    setLevel(level: any): this;
+    shouldLog(level: any): boolean;
+    formatMessage(args: any): any;
+    log(...args: any[]): void;
+    error(...args: any[]): void;
+    warn(...args: any[]): void;
+    info(...args: any[]): void;
+    debug(...args: any[]): void;
+    trace(...args: any[]): void;
+    time(label: any): void;
+    timeEnd(label: any): void;
+}
+export namespace LogLevel {
+    let ERROR: number;
+    let WARN: number;
+    let INFO: number;
+    let DEBUG: number;
+    let TRACE: number;
+    let NONE: number;
+}
+export {};

package/types/adapters/markdown.d.ts

@@ -0,0 +1,13 @@
+export function extractWikilinkTopics(markdown: any): string[];
+export function _setPlatform(platform: any): void;
+export function renderMarkdown(markdown: any, filePath: any): any;
+export function removeMD(...args: any[]): any;
+export const allEmoji: any;
+declare namespace _default {
+    export { extractWikilinkTopics };
+    export { renderMarkdown };
+    export { removeMD };
+    export { _setPlatform };
+    export { allEmoji };
+}
+export default _default;

package/types/adapters/parsers/DateLanguageParser.d.ts

@@ -0,0 +1 @@
+export function replaceDateLanguage(text: any, asDate?: boolean): any;

package/types/adapters/parsers/content-transformer.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Interpolates the content with the provided data.
+ * @param {string} content - The content to interpolate.
+ * @param {object} data - The data to use for interpolation.
+ * @param {object} opts - The options for interpolation.
+ * @returns {object} - The interpolated content, whether there was interpolation, and error tokens.
+ */
+export function interpolate(content: string, data: object, opts?: object): object;
+export function encodeMarkdownLinks(content: any): any;
+export function format(content: any, data: any, mustache: any): any;

package/types/adapters/parsers/file/LocalFileParserFactory.d.ts

@@ -0,0 +1,5 @@
+export function getLang(config: any, filePath: any): any;
+export function getLanguages(config: any): any;
+export function getFileParser(filePath: any, config: any, readStream: any): Promise<ReadStreamMarkdownParser | ReadStreamCodeParser>;
+import { ReadStreamMarkdownParser } from './ReadStreamMarkdownParser.js';
+import { ReadStreamCodeParser } from './ReadStreamCodeParser.js';

package/types/adapters/parsers/file/ReadStreamCodeParser.d.ts

@@ -0,0 +1,13 @@
+export class ReadStreamCodeParser extends ReadStreamTaskParser {
+    constructor(readStream: any, filePath: any, lang: any, lists: any);
+    lists: any;
+    filePath: any;
+    lang: any;
+    taskParsers: CodeStyleTaskParser[];
+    init(): Promise<void>;
+    cards: any[] | undefined;
+    parseCards(code: any, tokens?: string[]): any[];
+    parseComments(code: any): any;
+}
+import { ReadStreamTaskParser } from './ReadStreamTaskParser.js';
+import { CodeStyleTaskParser } from '../task/CodeStyleTaskParser.js';

package/types/adapters/parsers/file/ReadStreamMarkdownParser.d.ts

@@ -0,0 +1,7 @@
+export class ReadStreamMarkdownParser extends ReadStreamTaskParser {
+    constructor(readStream: any, config: any);
+    taskParsers: (HashStyleTaskParser | MarkdownStyleTaskParser)[];
+}
+import { ReadStreamTaskParser } from './ReadStreamTaskParser.js';
+import { HashStyleTaskParser } from '../task/HashStyleTaskParser.js';
+import { MarkdownStyleTaskParser } from '../task/MarkdownStyleTaskParser.js';

package/types/adapters/parsers/file/ReadStreamTaskParser.d.ts

@@ -0,0 +1,19 @@
+export class ReadStreamTaskParser {
+    constructor(readStream: any);
+    readStream: any;
+    task: any;
+    line: IteratorResult<string, any> | null;
+    taskParsers: any[];
+    lineNo: number;
+    blankLines: number;
+    readInterface: ReadLine.Interface;
+    readTask(): Promise<any>;
+    readLine(): Promise<IteratorResult<string, any>>;
+    isEndOfTask(line: any): boolean;
+    nextTask: any;
+    getTaskFromLine(line: any): undefined;
+    addLineToTask(line: any): void;
+    trimLinesToEndTask(): void;
+    close(): void;
+}
+import * as ReadLine from 'node:readline/promises';