imdone-core 1.54.10 → 2.0.1

package/lib/adapters/file-gateway.js

@@ -1,127 +1,154 @@
-const tools = require('../tools')
-const _path = require('path')
-let fs = require('fs')
-const sanitize = require('sanitize-filename')
+import _path from 'path'
+import _fs from 'fs'
+import sanitize from 'sanitize-filename'
+import { logger } from './logger.js'
 
-async function exists(path) {
+let fs = _fs
+
+export async function exists(path) {
   try {
-    await fs.promises.access(path)
-    return path
+    return await stat(path)
   } catch {
     return false
   }
 }
 
-function mkdirpSync(path) {
-  console.warn('sync call')
-  return require('mkdirp').sync(path, { fs })
-}
-
-function statSync(path) {
-  console.warn('sync call')
+export function statSync(path) {
+  logger.warn('statSync call')
   try {
     return fs.statSync(path)
   } catch {
   }
 }
 
-const gateway = {
-  init(fileSystem = fs) {
-    fs = fileSystem
-  },
+export function init(fileSystem = fs) {
+  fs = fileSystem
+}
 
-  sep: _path.sep,
+export const sep = _path.sep
 
-  existsSync(...args) {
-    console.warn('sync call')
-    return fs.existsSync.apply({}, args)
-  },
+export function existsSync(...args) {
+  logger.warn('existsSync call')
+  return fs.existsSync.apply({}, args)
+}
 
-  exists,
+export const stat = fs.promises.stat
 
-  async stat(path, opts) {
-    try {
-      return await fs.promises.stat(path, opts)
-    }
-    catch {
-      return false
-    }
-  },
-
-  readFileSync(...args) {
-    console.warn('sync call')
-    return fs.readFileSync.apply({}, args)
-  },
-
-  appendFileSync(...args) {
-    console.warn('sync call')
-    return fs.appendFileSync.apply({}, args)
-  },
-
-  writeFileSync(...args) {
-    console.warn('sync call')
-    return fs.writeFileSync.apply({}, args)
-  },
-
-  writeFile(...args) {
-    return fs.promises.writeFile.apply({}, args)
-  },
-
-  async readdir(...args) {
-    return fs.promises.readdir.apply({}, args)
-  },
-
-  unlinkSync(...args) {
-    console.warn('sync call')
-    return fs.unlinkSync.apply({}, args)
-  },
-
-  mkdirpSync,
-
-  async mkdir(path) {
-    return fs.promises.mkdir(path)
-  },
-
-  async readFile(path) {
-    return fs.promises.readFile(path, 'utf8')
-  },
-
-  statSync,
-
-  readdirSyncRecursive(path) {
-    console.warn('sync call')
-    return tools.readdirSyncRecursive(fs, path)
-  },
-
-  readdirSync(path) {
-    console.warn('sync call')
-    return fs.readdirSync(path, { withFileTypes: true })
-  },
-  
-  sanitizeFileName(fileName, replaceSpacesWith) {
-    // Remove markdown emoji
-    fileName = fileName.replace(/:\w+:/g, '').trim()
-    fileName = sanitize(fileName)
-    if (replaceSpacesWith)
-      fileName = fileName.replace(/ /g, replaceSpacesWith)
-    return fileName
-  },
-
-  preparePathForWriting(path) {
-    let stat = statSync(path)
-    if (!stat) {
-      let { dir, ext } = _path.parse(path)
-      if (!ext) {
-        dir = path
-      }
-      mkdirpSync(dir)
-      stat = statSync(path)
-    }
-    return {
-      isFile: stat && stat.isFile(),
-      isDirectory: stat && stat.isDirectory()
+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()
   }
 }
 
-module.exports = gateway
+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

@@ -1,13 +1,35 @@
-var wget = require('download');
+import fetch from 'node-fetch';
+import AdmZip from 'adm-zip';
+import { cp, rm } from './file-gateway.js'
+import path from 'node:path'
 
-module.exports = download;
+export async function downloadPlugin(repo, dest) {
+  const url = github(normalize(repo));
+  const response = await fetch(url);
 
-async function download(repo, dest) {
-  var url = github(normalize(repo));
-  return wget(url, dest, { extract: true, strip: 1 })
+  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){
+function github(repo) {
   return 'https://github.com/'
     + repo.owner
     + '/'
@@ -17,19 +39,17 @@ function github(repo){
     + '.zip';
 }
 
-function normalize(string){
-  var owner = string.split('/')[0];
-  var name = string.split('/')[1];
-  var branch = 'master';
+function normalize(string) {
+  let [owner, name] = string.split('/');
+  let branch = 'master';
 
-  if (~name.indexOf('#')) {
-    branch = name.split('#')[1];
-    name = name.split('#')[0];
+  if (name.includes('#')) {
+    [name, branch] = name.split('#');
   }
 
   return {
-    owner: owner,
-    name: name,
-    branch: branch
+    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

@@ -1,14 +1,17 @@
-const checkbox = require('markdown-it-checkbox')
-const imageSize = require('markdown-it-imsize')
-const emoji = require('markdown-it-emoji')
-const mark = require('markdown-it-mark')
-const removeMD = require('remove-markdown')
-const path = require('path');
-
-const MarkdownIt = require('markdown-it')
+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
 
-function extractWikilinkTopics(markdown) {
+export function extractWikilinkTopics(markdown) {
   const wikilinkRegex = /\[\[([a-zA-Z0-9\u00C0-\u017F/_\-. ]+)(?:\|([^\]]+))?\]\]/g;
   const topics = [];
   let match;
@@ -20,8 +23,21 @@ function extractWikilinkTopics(markdown) {
   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 = new MarkdownIt({html: true, breaks: true})
+  const md = markdownIt({html: true, breaks: true})
 
   md.use(checkbox)
   .use(mark)
@@ -155,14 +171,10 @@ function renderCancelledTasks(markdown) {
   return markdown.replace(/- \[-\] (.+)/gm, '- :no_entry_sign: ~~$1~~');
 }
 
-module.exports = {
-  _setPlatform(platform) {
-    _platform = platform
-  },
-  renderMarkdown (markdown, filePath) {
-    markdown = renderCancelledTasks(markdown)
-    return getRenderer(filePath).render(markdown)
-  },
+export default {
   extractWikilinkTopics,
-  removeMD  
+  renderMarkdown,
+  removeMD,
+  _setPlatform,
+  allEmoji
 }

package/lib/adapters/parsers/DateLanguageParser.js

@@ -1,10 +1,12 @@
-const chrono = require('chrono-node')
+import { Chrono } from 'chrono-node'
 
-module.exports = {
-  replaceDateLanguage(text, asDate) {
-    return text.replace(/\(?\${(.*?)}\)?/g, (match, p1) => {
-      const date = chrono.parseDate(p1)
-      return date ? date.toISOString() : p1
-    })
-  }
-}
+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;
+  });
+}