imdone-core 2.0.0 → 2.0.1

package/lib/card.js

@@ -0,0 +1,299 @@
+import { Task } from './task.js'
+import _path from 'path'
+import _pick from 'lodash.pick'
+import _isFunction from 'lodash.isfunction'
+import _isObject from 'lodash.isobject'
+import _isEmpty from 'lodash.isempty'
+import eol from 'eol'
+import { getFunctionSignature } from './adapters/parsers/function-parser.js'
+import { format, encodeMarkdownLinks, interpolate } from './adapters/parsers/content-transformer.js'
+import { removeMD } from './adapters/markdown.js'
+import { createRequire } from 'node:module';
+import { logger } from './adapters/logger.js'
+
+const require = createRequire(import.meta.url);
+export const allEmoji = require("markdown-it-emoji/lib/data/full.json")
+
+const CONTENT_TOKEN = '__CONTENT__'
+const lf = String(eol.lf)
+
+export function newCard(task, _project, dontParse) {
+  const project = _project
+  const pluginManager = _project && _project.pluginManager
+
+  class Card extends Task {
+    constructor(task, dontParse) {
+      super(project.config, task, dontParse)
+    }
+
+    get settings() {
+      return project.config.settings || {}
+    }
+
+    get maxLines() {
+      return project.config.maxLines
+    }
+
+    get interpretedContent() {
+      return this.innerInterpretedContent || this.getTextAndDescription()
+    }
+
+    set interpretedContent(value) {
+      this.innerInterpretedContent = value
+    }
+
+    // TODO This should take an object of project level data and make it available to the card
+    // <!--
+    // order:-120
+    // -->
+    init(totals = project.totals) {
+      this.updateLastLine()
+      this.totals = totals
+      this.onTaskUpdate()
+      this.initProps()
+      this.initComputed()
+      this.initData()
+      this.initActions()
+      return this
+    }
+
+    onTaskUpdate() {
+      // TODO We should be mapping to the imdone-api task
+      // #imdone-1.45.0
+      // <!--
+      // order:-20
+      // -->
+      const interpretedContent = pluginManager.onTaskUpdate(this)
+      if (interpretedContent && interpretedContent.length > 0) {
+        this.interpretedContent = interpretedContent
+      }
+    }
+
+    initProps() {
+      const props = this?.settings?.cards?.props ?? {}
+      this.props = this.frontMatter.props
+        ? { ...props, ...this.frontMatter.props }
+        : { ...props }
+    }
+
+    initComputed() {
+      const computed = this?.settings?.cards?.computed ?? {}
+      this.computed = this.frontMatter.computed
+        ? { ...computed, ...this.frontMatter.computed }
+        : { ...computed }
+    }
+
+    initActions() {
+      this.links = []
+      if (!pluginManager) return
+      this.links = [...pluginManager.getCardActions(this)]
+    }
+
+    get projectPath() {
+      return project.path
+    }
+
+    get relPath() {
+      return this.source ? this.source.path : undefined
+    }
+
+    get fullPath() {
+      return this.source ? _path.join(project.path, this.source.path) : undefined
+    }
+
+    get defaultData() {
+      return {
+        ..._pick(
+          this,
+          ...['beforeText',
+          'rawTask',
+          'id',
+          'text',
+          'progress',
+          'line',
+          'lastLine',
+          'list',
+          'source',
+          'due',
+          'created',
+          'started',
+          'completed',
+          'tags',
+          'context',
+          'meta',
+          'allTags',
+          'allContext',
+          'allMeta',
+          'metaKeys',
+          'content',
+          'filteredListName',
+          'interpretedContent',
+          'projectPath',
+          'relPath',
+          'fullPath',
+          'totals',
+          'topics'].sort()
+        ),
+      }
+    }
+
+    // TODO Add isInCodeFile property to card
+    // <!--
+    // order:-115
+    // -->
+    initData() {
+      const props = { ...this.props, content: CONTENT_TOKEN }
+      const computed = { ...this.computed }
+      const defaultData = this.defaultData
+      try {
+        for (let [key, value] of Object.entries(computed)) {
+          let computedValue = value.toString()
+          const computedProps = { ...props, ...computed, ...defaultData }
+          if (_isFunction(value) && !_isEmpty(props)) {
+            try {
+              // Call the computed function for a value
+              computedValue = value.call(computedProps)
+            } catch (e) {
+              logger.info(
+                `Unable to compute key: ${key} with value: ${computedValue}`,
+                e.message
+              )
+            }
+          } else {
+            try {
+              // Use template for the computed value
+              computedValue = interpolate(value, computedProps, { tags: ['${', '}'] })
+            } catch (e) {
+              logger.info(
+                `Unable to compute key: ${key} with value: ${computedValue}`,
+                e.message
+              )
+            }
+          }
+          computed[key] = computedValue
+        }
+      } catch (e) {
+        logger.error(e)
+      }
+
+      const pluginData = pluginManager
+        ? { ...pluginManager.getCardProperties(defaultData) }
+        : {}
+      const data = {
+        ...pluginData,
+        ...props,
+        ...computed,
+        ...defaultData
+      }
+
+      const keys = Object.keys(data).map((key) => {
+        const value = data[key]
+        if (_isFunction(value)) {
+          key = getFunctionSignature(value)
+        }
+        return key
+      })
+      
+      keys.forEach((key) => {
+        const value = data[key]
+        if (_isObject(value) && !Array.isArray(value)) {
+          keys.push(...Object.keys(value).map((k) => `${key}.${k}`))
+        }
+      })
+      this.dataKeys = keys
+
+      this.data = { ...data }
+      this.updateDescriptionData()
+    }
+
+    updateDescriptionData() {
+      this.desc = this.getDescriptionData()
+      this.data = { ...this.data, ...this.desc }
+    }
+
+    getEncodedContent(content) {
+      const linkRegex = /\[([^[]+)\](\((.*)\))/gm
+      const plainDescription = removeMD(content.replace(linkRegex, '$3'), {
+        stripListLeaders: false,
+      }).replace(/:(\w+):/g, (match, p1) => {
+        return allEmoji[p1]
+      })
+      const encodedText = encodeURIComponent(plainDescription)
+      const encodedMD = encodeURIComponent(content)
+      content = content.replace(CONTENT_TOKEN, encodedText)
+      content = encodeMarkdownLinks(content)
+      return { encodedMD, encodedText, content }
+    }
+
+    formatContent(content, mustache) {
+      return this.getEncodedContent(this.format(content, mustache))
+    }
+
+    format(content, mustache) {
+      const projectData = project ? { ...project.data } : {}
+      const data = { ...this.data, ...projectData }
+      return format(content, data, mustache)
+    }
+
+    getCardMarkdown() {
+      let taskMD = this.interpretedContent
+        .replace(/%%[\s\S]*?%%/g, '')
+        .replace(/<\!--\s*?-->/gs, '')
+        .trim()
+      const displayContent = []
+      const rawContent = []
+      const mdArray = eol.split(taskMD)
+      let titleFound = false
+      mdArray.forEach((line) => {
+        rawContent.push(line)
+        if (!titleFound && line === `${this.beforeText}${this.text}`) {
+          line = `<span class="imdone-card-title">${lf}${lf}${line}${lf}${lf}</span>${lf}`
+          titleFound = true
+        }
+        displayContent.push(line)
+      })
+      this.truncLines = titleFound ? this.maxLines + 5 : this.maxLines
+      const totalLines = displayContent.length
+      const markdown = displayContent.join(eol.lf)
+      const rawMarkdown = rawContent.join(eol.lf)
+      return { totalLines, markdown, rawMarkdown }
+    }
+
+    getHtml(content) {
+      const html = project.renderMarkdown(content, this.fullPath)
+      const mdArray = eol.split(content)
+      let truncHtml
+      if (mdArray.length > this.truncLines) {
+        mdArray.length = this.truncLines
+        truncHtml = project.renderMarkdown(mdArray.join(eol.lf), this.fullPath)
+      }
+      return { html, truncHtml }
+    }
+
+    getDescriptionData() {
+      const { markdown, rawMarkdown } = this.getCardMarkdown()
+
+      let { encodedText, encodedMD, content } = this.formatContent(
+        markdown,
+        true
+      )
+      const formattedRawMarkdown = this.formatContent(rawMarkdown, true).content
+      const { html, truncHtml } = this.getHtml(content)
+      const title = this.format(this.text, true)
+      return {
+        title,
+        html,
+        truncHtml,
+        encodedText,
+        encodedMD,
+        markdown: content,
+        rawMarkdown: formattedRawMarkdown,
+        htmlLength: html.length,
+        htmlTruncLength: truncHtml && truncHtml.length,
+        isOverMaxLines: truncHtml && truncHtml.length < html.length,
+      }
+    }
+  }
+
+  return new Card(task, dontParse)
+}

package/lib/checksum.js

@@ -0,0 +1,22 @@
+import { createHash } from 'crypto';
+import { readFile } from 'fs/promises';
+
+/**
+ * Compute a checksum for a given string or file.
+ * @param {string} input - The string or file path to hash.
+ * @param {string} algorithm - The hash algorithm to use (default: 'sha1').
+ * @param {boolean} isFile - Whether the input is a file path.
+ * @returns {Promise<string>} The computed checksum.
+ */
+export async function computeChecksum(input, algorithm = 'sha1', isFile = false) {
+  const hash = createHash(algorithm);
+
+  if (isFile) {
+    const fileBuffer = await readFile(input);
+    hash.update(fileBuffer);
+  } else {
+    hash.update(input);
+  }
+
+  return hash.digest('hex');
+}

package/lib/config.js

@@ -0,0 +1,249 @@
+/**
+ * Description
+ * @method Config
+ * @param {} opts
+ * @return
+ */
+const COLON = ':'
+const DOUBLE_COLON = '::'
+const META_SEPS = [COLON, DOUBLE_COLON]
+
+const JOURNAL_TYPE = {
+  SINGLE_FILE: 'Single File',
+  FOLDER: 'Folder',
+  NEW_FILE: 'New File',
+}
+
+const DEFAULT_CONFIG = {
+  keepEmptyPriority: false,
+  code: {
+    include_lists: [
+      'TODO',
+      'DOING',
+      'DONE',
+      'PLANNING',
+      'FIXME',
+      'ARCHIVE',
+      'HACK',
+      'CHANGED',
+      'XXX',
+      'IDEA',
+      'NOTE',
+      'REVIEW',
+    ],
+  },
+  lists: [
+    {
+      hidden: false,
+      name: 'TODO',
+    },
+    {
+      hidden: false,
+      name: 'DOING',
+    },
+    {
+      hidden: false,
+      name: 'DONE',
+    },
+  ],
+}
+
+export class Config {
+  constructor(opts) {
+    Object.assign(this, opts)
+    if (!this.settings) this.settings = {}
+    if (!this.settings.views) this.settings.views = []
+    if (!this.settings.cards) this.settings.cards = {}
+  }
+
+  static DEFAULT_CONFIG = DEFAULT_CONFIG
+  static JOURNAL_TYPE = JOURNAL_TYPE
+  
+  static newDefaultConfig(config = {}) {
+    return new Config(
+      {
+        ...DEFAULT_CONFIG, 
+        lists: [
+          ...DEFAULT_CONFIG.lists
+        ],
+        ...config
+      }
+    )
+  } 
+
+  get cards () {
+    return this?.settings?.cards
+  }
+
+  get defaultFilter() {
+    return this?.settings?.defaultFilter ?? ''
+  }
+
+  set defaultFilter(filter) {
+    this.settings.defaultFilter = filter
+  }
+
+  get name() {
+    return this?.settings?.name ?? ''
+  }
+
+  set name(name) {
+    this.settings.name = name
+  }
+
+  includeList(name) {
+    return this?.code?.include_lists?.includes(name)
+  }
+
+  ignoreList(name) {
+    const list = this?.lists?.find((list) => name === list.name)
+    return !list || (list && list.ignore)
+  }
+
+  listExists(name) {
+    return this?.lists?.findIndex((list) => list.name === name) > -1
+  }
+
+  getDefaultList() {
+    return  this?.cards?.defaultList ?? this.lists[0].name
+  }
+
+  getDoneList() {
+    const lists = structuredClone(this.lists).reverse().filter((list) => !list.filter)
+    return this?.cards?.doneList
+    || lists?.find(list => /dene|completed|finished/i.test(list?.name ?? ''))?.name 
+    || lists[0]?.name
+    || ''
+}
+
+  getDoingList() {
+    const lists = structuredClone(this.lists).filter((list) => !list.filter)
+    .reverse()
+    return this?.cards?.doingList 
+      || lists?.find(list => /doing|progress/i.test(list?.name ?? ''))?.name 
+      || lists[1]?.name
+      || ''
+  }
+
+  isAddNewCardsToTop() {
+    return this?.cards?.addNewCardsToTop ?? false
+  }
+
+  getNewCardSyntax() {
+    return this?.settings?.newCardSyntax?? 'MARKDOWN'
+  }
+
+  isMetaNewLine() {
+    return this?.cards?.metaNewLine ?? false
+  }
+
+  getTagPrefix() {
+    return this?.cards?.tagPrefix ?? '+'
+  }
+
+  getTaskPrefix() {
+    return this?.cards?.taskPrefix ?? '##'
+  }
+
+  isAddCheckBoxTasks() {
+    return this?.cards?.addCheckBoxTasks ?? false
+  }
+
+  isAddCompletedMeta() {
+    return this?.cards?.addCompletedMeta ?? false
+  }
+
+  get customCardTerminator() {
+    return this?.cards?.customCardTerminator
+  }
+
+  set customCardTerminator(terminator) {
+    this.settings.cards.customCardTerminator = terminator
+  }
+
+  get markdownOnly() {
+    return this?.settings?.markdownOnly
+  }
+
+  get views() {
+    return this?.settings?.views
+  }
+
+  get appendNewCardsTo() {
+    return this?.settings?.appendNewCardsTo ?? false
+  }
+
+  get ignoreFrontMatter() {
+    return this?.settings?.ignoreFrontMatter ?? false
+  }
+
+  get ignoreFrontMatterTags() {
+    return this?.settings?.ignoreFrontMatterTags ?? false
+  }
+
+  get journalPath() {
+    return this?.settings?.journalPath ?? ''
+  }
+
+  set journalPath(path) {
+    this.settings.journalPath = path
+  }
+
+  get journalTemplate() {
+    const template = this?.settings?.journalTemplate ?? ''
+    return template === 'null' ? '' : template || ''
+  }
+
+  get journalType() {
+    return this?.settings?.journalType ?? JOURNAL_TYPE.FOLDER
+  }
+
+  get journalFilePrefix() {
+    return this?.settings?.journalFilePrefix ?? ''
+  }
+
+  get journalFileSuffix() {
+    return this?.settings?.journalFileSuffix ?? ''
+  }
+
+  get replaceSpacesWith() {
+    return this?.settings?.replaceSpacesWith
+  }
+
+  get devMode() {
+    return this?.settings?.plugins?.devMode ?? false
+  }
+
+  get plugins() {
+    return this?.settings?.plugins ?? { devMode: this.devMode }
+  }
+
+  get orderMeta() {
+    return this?.cards?.orderMeta ?? false
+  }
+
+  get maxLines() {
+    return this?.cards?.maxLines ?? 1
+  }
+
+  get archiveFolder() {
+    return this?.cards?.archiveFolder ?? 'archive'
+  }
+
+  get archiveCompleted() {
+    return this?.cards?.archiveCompleted ?? false
+  }
+
+  get tokenPrefix() {
+    return this?.cards?.tokenPrefix ?? '#'
+  }
+
+  get doneList() {
+    return this.getDoneList()
+  }
+
+  getMetaSep() {
+    const metaSep = this?.cards?.metaSep ?? COLON
+    return META_SEPS.includes(metaSep) ? metaSep : COLON
+  }
+}

package/lib/constants.js

@@ -0,0 +1,68 @@
+import path from 'path'
+import { Config } from './config.js'
+
+var DEFAULT_IGNORE_PATHS = `
+node_modules
+bower_components
+target
+build
+dist*
+logs
+flow-typed
+.git
+.svn
+.hs
+.npmignore
+.obsidian
+.imdone/templates
+.imdone/tags.yml
+`
+var DEFAULT_IGNORE_EXTS = `
+*.jpg
+*.png
+*.gif
+*.swp
+*.ttf
+*.odf
+*.pdf
+*.doc*
+*.xls*
+*.ppt*
+*.pps*
+*.ppa*
+*.pot*
+`
+
+const DEFAULT_IGNORE = `
+${DEFAULT_IGNORE_PATHS}
+${DEFAULT_IGNORE_EXTS}
+`
+const CONFIG_DIR = '.imdone'
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json')
+const CONFIG_FILE_YML = path.join(CONFIG_DIR, 'config.yml')
+const SORT_FILE = path.join(CONFIG_DIR, 'sort.json')
+const TEMPLATES_DIR = path.join(CONFIG_DIR, 'templates')
+const { JOURNAL_TYPE, DEFAULT_CONFIG } = Config
+
+export const constants = {
+  JOURNAL_TYPE,
+  ASYNC_LIMIT: 512,
+  CONFIG_DIR,
+  CONFIG_FILE,
+  CONFIG_FILE_YML,
+  SORT_FILE,
+  TEMPLATES_DIR,
+  IGNORE_FILE: '.imdoneignore',
+  DEFAULT_FILE_PATTERN: '^(readme\\.md|home\\.md|readme\\.w+|home\\.w+)$',
+  DEFAULT_IGNORE,
+  DEFAULT_IGNORE_PATHS,
+  DEFAULT_IGNORE_EXTS,
+  ERRORS: {
+    NOT_A_FILE: 'file must be of type File',
+    CALLBACK_REQUIRED: 'Last paramter must be a callback function',
+    NO_CONTENT: 'File has no content',
+    LIST_NOT_FOUND: 'List not found',
+    TASK_NOT_FOUND: 'Task not found',
+  },
+  DEFAULT_CONFIG,
+}

package/lib/context/ApplicationContext.js

@@ -0,0 +1,35 @@
+import { Config } from '../config.js'
+import { getAvailablePlugins } from '../plugins/plugin-registry.js';
+
+class ApplicationContext {
+  constructor({
+    project,
+    repo,
+    projectContext,
+    projectReader,
+    projectPresenter,
+  }) {
+    this.project = project;
+    this.repo = repo;
+    this.projectContext = projectContext;
+    this.projectReader = projectReader;
+    this.projectPresenter = projectPresenter;
+    this.innerConfig = Config.newDefaultConfig()
+    this.pluginRegistry = { getAvailablePlugins }
+  }
+
+  set config(config) {
+    this.innerConfig = config 
+    this.repo && (this.repo.config = config)
+  }
+
+  get config() {
+    return this.repo?.config ?? this.innerConfig
+  }
+
+}
+const context = new ApplicationContext({})
+
+export function appContext() {
+  return context
+}

package/lib/context/index.js

@@ -0,0 +1 @@
+export * from './ApplicationContext.js';

package/lib/default-settings.js

@@ -0,0 +1,37 @@
+import { loadYAML } from './adapters/yaml.js'
+
+export const defaultSettingsString = `openIn: default #override
+openCodeIn: default #override
+journalType: New File
+journalPath: imdone-tasks #override
+appendNewCardsTo: imdone-tasks.md
+newCardSyntax: HASHTAG #override
+replaceSpacesWith: '-' #override
+plugins:
+  devMode: false
+cards:
+  colors: [] #override if
+  template: | # This is the template for new cards that are created in imdone
+    
+    
+    <!--
+    created:\${(new Date()).toISOString()}
+    -->
+  trackChanges: false #override
+  metaNewLine: false #override
+  addCompletedMeta: false #override
+  addCheckBoxTasks: false #override
+  doingList: DOING #override if
+  doneList: DONE #override if
+  tokenPrefix: '#' #override
+  taskPrefix: '##' #override
+  tagPrefix: '+' #override
+  metaSep: ':' #override
+  orderMeta: true
+  maxLines: 6 #override
+  addNewCardsToTop: true #override
+  showTagsAndMeta: true #override
+journalTemplate: #override
+markdownOnly: false #override
+`
+export const defaultSettings = loadYAML(defaultSettingsString)