imdone-core 2.0.0 → 2.0.1

package/lib/FileProjectContext.js

@@ -0,0 +1,13 @@
+import { toNumber } from "./adapters/parsers/task/CardContentParser.js";
+export class FileProjectContext {
+  constructor() {}
+  getOrder(list, order) {
+    return toNumber(order)
+  }
+
+  getProject() {
+    return
+  }
+
+}
+

package/lib/ProjectContext.js

@@ -0,0 +1,43 @@
+import { FileProjectContext } from './FileProjectContext.js'
+import { isNumber, toNumber } from './adapters/parsers/task/CardContentParser.js'
+
+export class ProjectContext extends FileProjectContext {
+  constructor(repo) {
+    super()
+    this.repo = repo
+  }
+
+  getOrder(list, order) {
+    const config = this.repo.config
+    if (config && config.keepEmptyPriority && order === undefined) return
+    const tasks =
+      list && this.repo.listExists(list) ? this.repo.getTasksInList(list) : []
+    return this.determineOrder(config, order, tasks)
+  }
+
+  get config() {
+    return this.repo.config
+  }
+
+  toJSON() {
+    return null
+  }
+
+  determineOrder(config, order, tasks) {
+    if (isNumber(order)) return toNumber(order)
+      if (!config) return
+    if (config.keepEmptyPriority) return
+    if (tasks) {
+      if (tasks.length == 0) {
+        return 0
+      } else if (config.isAddNewCardsToTop()) {
+        return (isNumber(tasks[0].order) ? toNumber(tasks[0].order) : 0) - 10
+      } else {
+        const lastTask = tasks[tasks.length - 1]
+        return (lastTask && isNumber(lastTask.order) ? lastTask.order : 0) + 10
+      }
+    }
+    return 0
+  }
+  
+}

package/lib/adapters/date-time.js

@@ -0,0 +1,15 @@
+import moment from "moment";
+let innerNoDST = false;
+
+export function setNoDST(noDST) {
+  innerNoDST = noDST;
+}
+
+export function getIsoDateWithOffset (date) {
+  const momentDate = moment(date);
+  if (momentDate.isDST() && innerNoDST) {
+    const offset = momentDate.utcOffset();
+    momentDate.utcOffset(offset - 60);
+  }
+  return momentDate.format();
+}

package/lib/adapters/environment.js

@@ -0,0 +1,3 @@
+export function isDev() {
+  return /dev/i.test(process.env.NODE_ENV)
+}

package/lib/adapters/file-gateway.js

@@ -0,0 +1,154 @@
+import _path from 'path'
+import _fs from 'fs'
+import sanitize from 'sanitize-filename'
+import { logger } from './logger.js'
+
+let fs = _fs
+
+export async function exists(path) {
+  try {
+    return await stat(path)
+  } catch {
+    return false
+  }
+}
+
+export function statSync(path) {
+  logger.warn('statSync call')
+  try {
+    return fs.statSync(path)
+  } catch {
+  }
+}
+
+export function init(fileSystem = fs) {
+  fs = fileSystem
+}
+
+export const sep = _path.sep
+
+export function existsSync(...args) {
+  logger.warn('existsSync call')
+  return fs.existsSync.apply({}, args)
+}
+
+export const stat = fs.promises.stat
+
+export const lstat = fs.promises.lstat
+
+export const lstatSync = fs.lstatSync
+
+export function readFileSync(...args) {
+  logger.warn('readFileSync call')
+  return fs.readFileSync.apply({}, args)
+}
+
+export function appendFileSync(...args) {
+  logger.warn('appendFileSync call')
+  return fs.appendFileSync.apply({}, args)
+}
+
+export function writeFileSync(...args) {
+  logger.warn('writeFileSync call')
+  return fs.writeFileSync.apply({}, args)
+}
+
+export const writeFile = fs.promises.writeFile
+
+export async function readdir(...args) {
+  return fs.promises.readdir.apply({}, args)
+}
+
+export function unlinkSync(...args) {
+  logger.warn('unlinkSync call')
+  return fs.unlinkSync.apply({}, args)
+}
+
+export const unlink = fs.promises.unlink
+
+export const mkdir = fs.promises.mkdir
+
+export const readFile = fs.promises.readFile
+
+export function readdirSyncRecursive(path) {
+  logger.warn('readdirSyncRecursive call')
+  // implement this function
+  let results = []
+  let list = fs.readdirSync(path)
+  list.forEach(function(file) {
+    file = _path.join(path, file)
+    let stat = fs.statSync(file)
+    if (stat && stat.isDirectory()) {
+      results = results.concat(readdirSyncRecursive(file))
+    } else {
+      results.push(file)
+    }
+  })
+  return results
+}
+
+export function readdirSync(path) {
+  logger.warn('readdirSync call')
+  return fs.readdirSync(path, { withFileTypes: true })
+}
+
+export function sanitizeFileName(fileName, replaceSpacesWith) {
+  // Remove markdown emoji
+  fileName = fileName.replace(/:\w+:/g, '').trim()
+  fileName = sanitize(fileName)
+  if (replaceSpacesWith)
+    fileName = fileName.replace(/ /g, replaceSpacesWith)
+  return fileName
+}
+
+function statsProps(stats) {
+  return {
+    isFile: stats.isFile(),
+    isDirectory: stats.isDirectory()
+  }
+}
+
+export async function preparePathForWriting(path, directory = false) {
+  let stats = await exists(path)
+  if (stats) return statsProps(stats)
+
+  let { dir } = directory ? { dir: path } : _path.parse(path)
+  stats = await exists(dir)
+  if (stats) return statsProps(stats)
+
+  await mkdir(dir, { recursive: true })
+  stats = await exists(dir)
+  return statsProps(stats)
+}
+
+export async function cp(src, dest, opts) {
+  return fs.promises.cp(src, dest, opts)
+}
+
+export async function rm(path, opts) {
+  return fs.promises.rm(path, opts)
+}
+
+export default {
+  cp,
+  rm,
+  exists,
+  stat,
+  lstat,
+  lstatSync,
+  readFileSync,
+  appendFileSync,
+  writeFileSync,
+  writeFile,
+  readdir,
+  unlink,
+  mkdir,
+  readFile,
+  readdirSyncRecursive,
+  readdirSync,
+  sanitizeFileName,
+  preparePathForWriting,
+  unlinkSync,
+  existsSync,
+  sep
+}

package/lib/adapters/git-download.js

@@ -0,0 +1,55 @@
+import fetch from 'node-fetch';
+import AdmZip from 'adm-zip';
+import { cp, rm } from './file-gateway.js'
+import path from 'node:path'
+
+export async function downloadPlugin(repo, dest) {
+  const url = github(normalize(repo));
+  const response = await fetch(url);
+
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ${url}: ${response.statusText}`);
+  }
+
+  const arrayBuffer = await response.arrayBuffer();
+  const buffer = Buffer.from(arrayBuffer);
+  const zip = AdmZip(buffer);
+  await zip.extractAllToAsync(dest, true);
+  const zipEntries = zip.getEntries();
+  const rootFolder = zipEntries[0].entryName.split(path.sep)[0];
+  const rootFolderPath = path.join(dest, rootFolder)
+  await cp(rootFolderPath, dest, {
+    recursive: true,
+    force: true,      // overwrite if needed
+    errorOnExist: false,
+  });
+  await rm(rootFolderPath, {
+    recursive: true,
+    force: true,      // overwrite if needed
+  });
+}
+
+function github(repo) {
+  return 'https://github.com/'
+    + repo.owner
+    + '/'
+    + repo.name
+    + '/archive/'
+    + repo.branch
+    + '.zip';
+}
+
+function normalize(string) {
+  let [owner, name] = string.split('/');
+  let branch = 'master';
+
+  if (name.includes('#')) {
+    [name, branch] = name.split('#');
+  }
+
+  return {
+    owner,
+    name,
+    branch
+  };
+}

package/lib/adapters/index.js

@@ -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/lib/adapters/logger.js

@@ -0,0 +1,136 @@
+import { info, error as consoleError, warn as consoleWarn } from 'console'
+
+// Log levels with numeric values for comparison
+const LogLevel = {
+  ERROR: 0,
+  WARN: 1,
+  INFO: 2,
+  DEBUG: 3,
+  TRACE: 4,
+  NONE: -1  // Use this to disable all logging
+}
+
+function getCallerInfo() {
+  const err = new Error();
+  const stack = err.stack?.split('\n');
+
+  if (!stack || stack.length < 5) return {};
+
+  // stack[0] is "Error"
+  // stack[1] is this function (getCallerInfo)
+  // stack[2] is the formatMessage method
+  // stack[3] is the logger method (log, info, debug, etc.)
+  // stack[4] is the actual caller we want
+
+  const callerLine = stack[4] || stack[3]; // Get the actual caller, fallback to logger method if needed
+  const match = callerLine.match(/at (.+?) \((.+):(\d+):(\d+)\)/) ||
+                callerLine.match(/at (.+):(\d+):(\d+)/);
+
+  if (match) {
+    if (match.length === 5) {
+      return {
+        functionName: match[1],
+        file: match[2],
+        line: parseInt(match[3], 10),
+        column: parseInt(match[4], 10)
+      };
+    } else if (match.length === 4) {
+      return {
+        functionName: '<anonymous>',
+        file: match[1],
+        line: parseInt(match[2], 10),
+        column: parseInt(match[3], 10)
+      };
+    }
+  }
+
+  return {};
+}
+
+class Logger {
+  constructor() {
+    // Default log level
+    this.level = LogLevel.INFO
+  }
+
+  // Setter for log level
+  setLevel(level) {
+    if (level in LogLevel) {
+      this.level = LogLevel[level]
+    } else if (typeof level === 'number' && level >= -1 && level <= 4) {
+      this.level = level
+    } else {
+      consoleWarn(`Invalid log level: ${level}. Using default INFO level.`)
+    }
+    return this
+  }
+
+  // Check if the provided level should be logged
+  shouldLog(level) {
+    return level <= this.level
+  }
+
+  formatMessage(args) {
+    const info = getCallerInfo();
+    const prefix = info.file ? `[${info.file}:${info.line}] ${info.functionName} - ` : '';
+    
+    if (typeof args[0] === 'string') {
+      args[0] = prefix + args[0];
+    } else {
+      args.unshift(prefix);
+    }
+    
+    return args;
+  }
+
+  log(...args) {
+    if (this.shouldLog(LogLevel.INFO)) {
+      info(...this.formatMessage(args));
+    }
+  }
+
+  error(...args) {
+    if (this.shouldLog(LogLevel.ERROR)) {
+      consoleError(...this.formatMessage(args));
+    }
+  }
+
+  warn(...args) {
+    if (this.shouldLog(LogLevel.WARN)) {
+      consoleWarn(...this.formatMessage(args));
+    }
+  }
+
+  info(...args) {
+    if (this.shouldLog(LogLevel.INFO)) {
+      info(...this.formatMessage(args));
+    }
+  }
+
+  debug(...args) {
+    if (this.shouldLog(LogLevel.DEBUG)) {
+      info(`[DEBUG]`, ...this.formatMessage(args));
+    }
+  }
+
+  trace(...args) {
+    if (this.shouldLog(LogLevel.TRACE)) {
+      info(`[TRACE]`, ...this.formatMessage(args));
+    }
+  }
+
+  time(label) {
+    if (this.shouldLog(LogLevel.DEBUG)) {
+      console.time(label)
+    }
+  }
+
+  timeEnd(label) {
+    if (this.shouldLog(LogLevel.DEBUG)) {
+      console.timeEnd(label)
+    }
+  }
+}
+
+export const logger = new Logger()
+export { LogLevel }

package/lib/adapters/markdown.js

@@ -0,0 +1,180 @@
+import checkbox from 'markdown-it-checkbox';
+import imageSize from 'markdown-it-imsize';
+import emoji from 'markdown-it-emoji';
+import mark from 'markdown-it-mark';
+import _removeMD from 'remove-markdown';
+import path from 'path';
+import markdownIt from 'markdown-it';
+import { createRequire } from 'module';
+
+export const allEmoji = createRequire(import.meta.url)('markdown-it-emoji/lib/data/full.json')
+
+let _platform = process.platform
+
+export function extractWikilinkTopics(markdown) {
+  const wikilinkRegex = /\[\[([a-zA-Z0-9\u00C0-\u017F/_\-. ]+)(?:\|([^\]]+))?\]\]/g;
+  const topics = [];
+  let match;
+
+  while ((match = wikilinkRegex.exec(markdown)) !== null) {
+    topics.push(match[1].trim()); // Always extract the topic (first capture group)
+  }
+
+  return topics;
+}
+
+export function _setPlatform(platform) {
+  _platform = platform
+}
+
+export function renderMarkdown (markdown, filePath) {
+  markdown = renderCancelledTasks(markdown)
+  return getRenderer(filePath).render(markdown)
+}
+
+export function removeMD() {
+  return _removeMD.apply({}, arguments)
+}
+
+function getRenderer(filePath) {
+  const md = markdownIt({html: true, breaks: true})
+
+  md.use(checkbox)
+  .use(mark)
+  .use(emoji)
+  .use(imageSize)
+  .use(obsidianTopicLinks(filePath))
+  .use(replaceImagePaths(filePath))
+  .use(replaceLinkPathsAndTitles(filePath))
+  .validateLink = () => true
+
+  return md
+}
+
+function obsidianTopicLinks(filePath) {
+  return function(md) {
+    const obsidianLinkRegex = /^\[\[([a-zA-Z0-9\u00C0-\u017F/_\-. ]+)(?:\|([^\]]+))?\]\]/; // No 'g' flag
+
+    function obsidianLinkRenderer(state, silent) {
+      const pos = state.pos;
+      const match = state.src.slice(pos).match(obsidianLinkRegex); // Always start from `pos`
+
+      if (!match) return false;
+      if (silent) return true; // Don't process further in silent mode
+
+      const fullMatch = match[0];
+      let topic = match[1].trim();
+      const alias = match[2] ? match[2].trim() : topic;
+      if (!topic.endsWith('.md')) topic = `${topic}.md`;
+      const unencodedHref = resolveFileUrl(topic, filePath);
+      const href = encodeURI(unencodedHref);
+
+      // Create a new token
+      const token = state.push("obsidian_link", "", 0);
+      token.content = `<a href="${href}" title="${unencodedHref}">${md.utils.escapeHtml(alias)}</a>`;
+
+      // Move parsing position forward
+      state.pos += fullMatch.length;
+      return true;
+    }
+
+    function render(tokens, idx) {
+      return tokens[idx].content;
+    }
+
+    md.inline.ruler.before("link", "obsidian_link", obsidianLinkRenderer);
+    md.renderer.rules.obsidian_link = render;
+  }
+}
+
+
+function replaceImagePaths(filePath) {
+
+  return function(md) {
+    const defaultRender = md.renderer.rules.image || function(tokens, idx, options, env, self) {
+      return self.renderToken(tokens, idx, options);
+    };
+
+    md.renderer.rules.image = function(tokens, idx, options, env, self) {
+      const token = tokens[idx];
+      const srcIndex = token.attrIndex('src');
+      if (srcIndex >= 0) {
+        const src = token.attrs[srcIndex][1];
+        const srcUrl = !isUrl(src) && resolveFileUrl(src, filePath)
+        if (srcUrl) token.attrs[srcIndex][1] = srcUrl;
+      }
+
+      return defaultRender(tokens, idx, options, env, self);
+    };
+  }
+}
+
+function replaceLinkPathsAndTitles(filePath) {
+
+  return function(md) {
+    const defaultRender = md.renderer.rules.link_open || function(tokens, idx, options, env, self) {
+      return self.renderToken(tokens, idx, options);
+    };
+
+    md.renderer.rules.link_open = function(tokens, idx, options, env, self) {
+      const token = tokens[idx];
+      const srcIndex = token.attrIndex('href');
+      if (srcIndex >= 0) {
+        const src = token.attrs[srcIndex][1];
+        const srcUrl = !isUrl(src) && resolveFileUrl(src, filePath)
+        if (srcUrl) token.attrs[srcIndex][1] = srcUrl;
+      }
+
+      // set the title to the href if it's not already set
+      const titleIndex = token.attrIndex('title');
+      if (titleIndex < 0) {
+        const title = token.attrs[srcIndex][1];
+        token.attrPush(['title', title]);
+      }
+      return defaultRender(tokens, idx, options, env, self);
+    };
+  }
+}
+
+function isUrl(href) {
+  try {
+    new URL(href);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+function resolveFileUrl(src, filePath) {
+  const dirname = _platform === 'win32' ? path.win32.dirname : path.dirname;
+  const resolve = _platform === 'win32' ? path.win32.resolve : path.resolve;
+
+  if (src.startsWith('file://')) return src;
+  if (/^\.?\/$/.test(src)) src = './';
+  const srcDir = dirname(filePath);
+  const srcPath = resolve(srcDir, src) // filePath ? path.join(filePath, src) : path.resolve(src);
+  const srcUrl = pathToFileURL(srcPath);
+  if (src.endsWith('/')) return srcUrl + '/';
+
+  return srcUrl;
+
+}
+
+function pathToFileURL(absolutePath) {
+  if (_platform === 'win32') {
+    absolutePath = '/' + absolutePath.replace(/\\/g, '/');
+  }
+  return `file://${absolutePath}`;
+}
+
+function renderCancelledTasks(markdown) {
+  return markdown.replace(/- \[-\] (.+)/gm, '- :no_entry_sign: ~~$1~~');
+}
+
+export default {
+  extractWikilinkTopics,
+  renderMarkdown,
+  removeMD,
+  _setPlatform,
+  allEmoji
+}

package/lib/adapters/parsers/DateLanguageParser.js

@@ -0,0 +1,12 @@
+import { Chrono } from 'chrono-node'
+
+export function replaceDateLanguage(text, asDate = false) {
+  const chrono = new Chrono();
+  return text.replace(/\(?\${(.*?)}\)?/g, (match, p1) => {
+    const date = chrono.parseDate(p1);
+    if (date) {
+      return asDate ? date : date.toISOString();
+    }
+    return match;
+  });
+}