@standardnotes/community-cdn 0.6.2 → 0.6.3

package/dist/zips/com.sncommunity.minimal-markdown/dist/sn-codemirror-search/searchcursor.js

@@ -0,0 +1,293 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: https://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"))
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod)
+  else // Plain browser env
+    mod(CodeMirror)
+})(function(CodeMirror) {
+  "use strict"
+  var Pos = CodeMirror.Pos
+
+  function regexpFlags(regexp) {
+    var flags = regexp.flags
+    return flags != null ? flags : (regexp.ignoreCase ? "i" : "")
+      + (regexp.global ? "g" : "")
+      + (regexp.multiline ? "m" : "")
+  }
+
+  function ensureFlags(regexp, flags) {
+    var current = regexpFlags(regexp), target = current
+    for (var i = 0; i < flags.length; i++) if (target.indexOf(flags.charAt(i)) == -1)
+      target += flags.charAt(i)
+    return current == target ? regexp : new RegExp(regexp.source, target)
+  }
+
+  function maybeMultiline(regexp) {
+    return /\\s|\\n|\n|\\W|\\D|\[\^/.test(regexp.source)
+  }
+
+  function searchRegexpForward(doc, regexp, start) {
+    regexp = ensureFlags(regexp, "g")
+    for (var line = start.line, ch = start.ch, last = doc.lastLine(); line <= last; line++, ch = 0) {
+      regexp.lastIndex = ch
+      var string = doc.getLine(line), match = regexp.exec(string)
+      if (match)
+        return {from: Pos(line, match.index),
+                to: Pos(line, match.index + match[0].length),
+                match: match}
+    }
+  }
+
+  function searchRegexpForwardMultiline(doc, regexp, start) {
+    if (!maybeMultiline(regexp)) return searchRegexpForward(doc, regexp, start)
+
+    regexp = ensureFlags(regexp, "gm")
+    var string, chunk = 1
+    for (var line = start.line, last = doc.lastLine(); line <= last;) {
+      // This grows the search buffer in exponentially-sized chunks
+      // between matches, so that nearby matches are fast and don't
+      // require concatenating the whole document (in case we're
+      // searching for something that has tons of matches), but at the
+      // same time, the amount of retries is limited.
+      for (var i = 0; i < chunk; i++) {
+        if (line > last) break
+        var curLine = doc.getLine(line++)
+        string = string == null ? curLine : string + "\n" + curLine
+      }
+      chunk = chunk * 2
+      regexp.lastIndex = start.ch
+      var match = regexp.exec(string)
+      if (match) {
+        var before = string.slice(0, match.index).split("\n"), inside = match[0].split("\n")
+        var startLine = start.line + before.length - 1, startCh = before[before.length - 1].length
+        return {from: Pos(startLine, startCh),
+                to: Pos(startLine + inside.length - 1,
+                        inside.length == 1 ? startCh + inside[0].length : inside[inside.length - 1].length),
+                match: match}
+      }
+    }
+  }
+
+  function lastMatchIn(string, regexp) {
+    var cutOff = 0, match
+    for (;;) {
+      regexp.lastIndex = cutOff
+      var newMatch = regexp.exec(string)
+      if (!newMatch) return match
+      match = newMatch
+      cutOff = match.index + (match[0].length || 1)
+      if (cutOff == string.length) return match
+    }
+  }
+
+  function searchRegexpBackward(doc, regexp, start) {
+    regexp = ensureFlags(regexp, "g")
+    for (var line = start.line, ch = start.ch, first = doc.firstLine(); line >= first; line--, ch = -1) {
+      var string = doc.getLine(line)
+      if (ch > -1) string = string.slice(0, ch)
+      var match = lastMatchIn(string, regexp)
+      if (match)
+        return {from: Pos(line, match.index),
+                to: Pos(line, match.index + match[0].length),
+                match: match}
+    }
+  }
+
+  function searchRegexpBackwardMultiline(doc, regexp, start) {
+    regexp = ensureFlags(regexp, "gm")
+    var string, chunk = 1
+    for (var line = start.line, first = doc.firstLine(); line >= first;) {
+      for (var i = 0; i < chunk; i++) {
+        var curLine = doc.getLine(line--)
+        string = string == null ? curLine.slice(0, start.ch) : curLine + "\n" + string
+      }
+      chunk *= 2
+
+      var match = lastMatchIn(string, regexp)
+      if (match) {
+        var before = string.slice(0, match.index).split("\n"), inside = match[0].split("\n")
+        var startLine = line + before.length, startCh = before[before.length - 1].length
+        return {from: Pos(startLine, startCh),
+                to: Pos(startLine + inside.length - 1,
+                        inside.length == 1 ? startCh + inside[0].length : inside[inside.length - 1].length),
+                match: match}
+      }
+    }
+  }
+
+  var doFold, noFold
+  if (String.prototype.normalize) {
+    doFold = function(str) { return str.normalize("NFD").toLowerCase() }
+    noFold = function(str) { return str.normalize("NFD") }
+  } else {
+    doFold = function(str) { return str.toLowerCase() }
+    noFold = function(str) { return str }
+  }
+
+  // Maps a position in a case-folded line back to a position in the original line
+  // (compensating for codepoints increasing in number during folding)
+  function adjustPos(orig, folded, pos, foldFunc) {
+    if (orig.length == folded.length) return pos
+    for (var min = 0, max = pos + Math.max(0, orig.length - folded.length);;) {
+      if (min == max) return min
+      var mid = (min + max) >> 1
+      var len = foldFunc(orig.slice(0, mid)).length
+      if (len == pos) return mid
+      else if (len > pos) max = mid
+      else min = mid + 1
+    }
+  }
+
+  function searchStringForward(doc, query, start, caseFold) {
+    // Empty string would match anything and never progress, so we
+    // define it to match nothing instead.
+    if (!query.length) return null
+    var fold = caseFold ? doFold : noFold
+    var lines = fold(query).split(/\r|\n\r?/)
+
+    search: for (var line = start.line, ch = start.ch, last = doc.lastLine() + 1 - lines.length; line <= last; line++, ch = 0) {
+      var orig = doc.getLine(line).slice(ch), string = fold(orig)
+      if (lines.length == 1) {
+        var found = string.indexOf(lines[0])
+        if (found == -1) continue search
+        var start = adjustPos(orig, string, found, fold) + ch
+        return {from: Pos(line, adjustPos(orig, string, found, fold) + ch),
+                to: Pos(line, adjustPos(orig, string, found + lines[0].length, fold) + ch)}
+      } else {
+        var cutFrom = string.length - lines[0].length
+        if (string.slice(cutFrom) != lines[0]) continue search
+        for (var i = 1; i < lines.length - 1; i++)
+          if (fold(doc.getLine(line + i)) != lines[i]) continue search
+        var end = doc.getLine(line + lines.length - 1), endString = fold(end), lastLine = lines[lines.length - 1]
+        if (endString.slice(0, lastLine.length) != lastLine) continue search
+        return {from: Pos(line, adjustPos(orig, string, cutFrom, fold) + ch),
+                to: Pos(line + lines.length - 1, adjustPos(end, endString, lastLine.length, fold))}
+      }
+    }
+  }
+
+  function searchStringBackward(doc, query, start, caseFold) {
+    if (!query.length) return null
+    var fold = caseFold ? doFold : noFold
+    var lines = fold(query).split(/\r|\n\r?/)
+
+    search: for (var line = start.line, ch = start.ch, first = doc.firstLine() - 1 + lines.length; line >= first; line--, ch = -1) {
+      var orig = doc.getLine(line)
+      if (ch > -1) orig = orig.slice(0, ch)
+      var string = fold(orig)
+      if (lines.length == 1) {
+        var found = string.lastIndexOf(lines[0])
+        if (found == -1) continue search
+        return {from: Pos(line, adjustPos(orig, string, found, fold)),
+                to: Pos(line, adjustPos(orig, string, found + lines[0].length, fold))}
+      } else {
+        var lastLine = lines[lines.length - 1]
+        if (string.slice(0, lastLine.length) != lastLine) continue search
+        for (var i = 1, start = line - lines.length + 1; i < lines.length - 1; i++)
+          if (fold(doc.getLine(start + i)) != lines[i]) continue search
+        var top = doc.getLine(line + 1 - lines.length), topString = fold(top)
+        if (topString.slice(topString.length - lines[0].length) != lines[0]) continue search
+        return {from: Pos(line + 1 - lines.length, adjustPos(top, topString, top.length - lines[0].length, fold)),
+                to: Pos(line, adjustPos(orig, string, lastLine.length, fold))}
+      }
+    }
+  }
+
+  function SearchCursor(doc, query, pos, options) {
+    this.atOccurrence = false
+    this.doc = doc
+    pos = pos ? doc.clipPos(pos) : Pos(0, 0)
+    this.pos = {from: pos, to: pos}
+
+    var caseFold
+    if (typeof options == "object") {
+      caseFold = options.caseFold
+    } else { // Backwards compat for when caseFold was the 4th argument
+      caseFold = options
+      options = null
+    }
+
+    if (typeof query == "string") {
+      if (caseFold == null) caseFold = false
+      this.matches = function(reverse, pos) {
+        return (reverse ? searchStringBackward : searchStringForward)(doc, query, pos, caseFold)
+      }
+    } else {
+      query = ensureFlags(query, "gm")
+      if (!options || options.multiline !== false)
+        this.matches = function(reverse, pos) {
+          return (reverse ? searchRegexpBackwardMultiline : searchRegexpForwardMultiline)(doc, query, pos)
+        }
+      else
+        this.matches = function(reverse, pos) {
+          return (reverse ? searchRegexpBackward : searchRegexpForward)(doc, query, pos)
+        }
+    }
+  }
+
+  SearchCursor.prototype = {
+    findNext: function() {return this.find(false)},
+    findPrevious: function() {return this.find(true)},
+
+    find: function(reverse) {
+      var result = this.matches(reverse, this.doc.clipPos(reverse ? this.pos.from : this.pos.to))
+
+      // Implements weird auto-growing behavior on null-matches for
+      // backwards-compatiblity with the vim code (unfortunately)
+      while (result && CodeMirror.cmpPos(result.from, result.to) == 0) {
+        if (reverse) {
+          if (result.from.ch) result.from = Pos(result.from.line, result.from.ch - 1)
+          else if (result.from.line == this.doc.firstLine()) result = null
+          else result = this.matches(reverse, this.doc.clipPos(Pos(result.from.line - 1)))
+        } else {
+          if (result.to.ch < this.doc.getLine(result.to.line).length) result.to = Pos(result.to.line, result.to.ch + 1)
+          else if (result.to.line == this.doc.lastLine()) result = null
+          else result = this.matches(reverse, Pos(result.to.line + 1, 0))
+        }
+      }
+
+      if (result) {
+        this.pos = result
+        this.atOccurrence = true
+        return this.pos.match || true
+      } else {
+        var end = Pos(reverse ? this.doc.firstLine() : this.doc.lastLine() + 1, 0)
+        this.pos = {from: end, to: end}
+        return this.atOccurrence = false
+      }
+    },
+
+    from: function() {if (this.atOccurrence) return this.pos.from},
+    to: function() {if (this.atOccurrence) return this.pos.to},
+
+    replace: function(newText, origin) {
+      if (!this.atOccurrence) return
+      var lines = CodeMirror.splitLines(newText)
+      this.doc.replaceRange(lines, this.pos.from, this.pos.to, origin)
+      this.pos.to = Pos(this.pos.from.line + lines.length - 1,
+                        lines[lines.length - 1].length + (lines.length == 1 ? this.pos.from.ch : 0))
+    }
+  }
+
+  CodeMirror.defineExtension("getSearchCursor", function(query, pos, caseFold) {
+    return new SearchCursor(this.doc, query, pos, caseFold)
+  })
+  CodeMirror.defineDocExtension("getSearchCursor", function(query, pos, caseFold) {
+    return new SearchCursor(this, query, pos, caseFold)
+  })
+
+  CodeMirror.defineExtension("selectMatches", function(query, caseFold) {
+    var ranges = []
+    var cur = this.getSearchCursor(query, this.getCursor("from"), caseFold)
+    while (cur.findNext()) {
+      if (CodeMirror.cmpPos(cur.to(), this.getCursor("to")) > 0) break
+      ranges.push({anchor: cur.from(), head: cur.to()})
+    }
+    if (ranges.length)
+      this.setSelections(ranges, 0)
+  })
+});

package/dist/zips/com.sncommunity.minimal-markdown/index.html

@@ -0,0 +1,23 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <base target="_blank">
+    <meta charset="UTF-8">
+
+    <script src="dist/dist.js"></script>
+
+    <script src="dist/sn-codemirror-search/search.js"></script>
+    <script src="dist/sn-codemirror-search/searchcursor.js"></script>
+    <script src="dist/sn-codemirror-search/dialog/dialog.js"></script>
+
+    <link rel="stylesheet" media="all" href="dist/dist.css">
+    <link rel="stylesheet" media="all" href="dist/sn-codemirror-search/dialog/dialog.css">
+  </head>
+
+  <body>
+    <div id="wrapper">
+      <textarea id="code" name="code"></textarea>
+    <div>
+
+  </body>
+</html>

package/dist/zips/com.sncommunity.minimal-markdown/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@sncommunity/markdown-minimal",
+  "private": true,
+  "version": "1.2.0",
+  "description": "A minimal Markdown editor for Standard Notes.",
+  "author": "Standard Notes Retired",
+  "main": "dist/dist.js",
+  "sn": {
+    "name": "Minimal Markdown",
+    "content_type": "SN|Component",
+    "main": "index.html",
+    "area": "editor-editor",
+    "spellcheckControl": true,
+    "note_type": "markdown",
+    "file_type": "txt"
+  },
+  "scripts": {
+    "build": "grunt",
+    "test": "echo \"Error: no test specified\" && exit 0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.11.1",
+    "@babel/preset-env": "^7.11.0",
+    "@standardnotes/component-relay": "standardnotes/component-relay#839ff5db9bc92db9d42cad8d202ddc4df729597d",
+    "babel-cli": "^6.26.0",
+    "codemirror": "^5.56.0",
+    "grunt": "^1.2.1",
+    "grunt-babel": "^8.0.0",
+    "grunt-browserify": "^5.3.0",
+    "grunt-contrib-concat": "^1.0.1",
+    "grunt-contrib-copy": "^1.0.0",
+    "grunt-contrib-sass": "^1.0.0",
+    "grunt-contrib-watch": "^1.1.0",
+    "grunt-newer": "^1.3.0",
+    "sass": "*",
+    "sn-codemirror-search": "1.0.0",
+    "sn-stylekit": "2.1.0"
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@standardnotes/community-cdn",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "license": "AGPL-3.0-or-later",
   "author": "Standard Notes Community",
   "publishConfig": {
@@ -17,5 +17,5 @@
     "minimatch": "^5.1.0",
     "typescript": "*"
   },
-  "gitHead": "c8986cce3e98b2b919c02be5b3fb68d5dee904bd"
+  "gitHead": "a989893452a5b8d13b63b0a789e9c1cba078403a"
 }

package/scripts/Compile.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+
+echo 'Building packages from' $(pwd)
+
+yarn build
+
+echo "Packaging packages assets and zips..."
+
+yarn run package
+git add dist
+git add ../README.md
+(git commit -m 'chore(release): packages') || true

package/scripts/Package.mjs

@@ -0,0 +1,188 @@
+console.log('Entered packaging script...')
+
+import fs from 'fs'
+import path from 'path'
+import crypto from 'crypto'
+import { fileURLToPath } from 'url'
+import { spawnSync as spawn } from 'child_process'
+
+import zip from '@standardnotes/deterministic-zip'
+import minimatch from 'minimatch'
+
+import { ensureDirExists, doesDirExist, emptyExistingDir } from '../../scripts/ScriptUtils.mjs'
+
+import { writePackageDirectoryToReadme } from './Readme.mjs'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+console.log('Beginning packaging procedure...')
+
+const Packages = JSON.parse(fs.readFileSync(path.join(__dirname, '../plugins.json')).toString())
+const SourceFilesPath = path.join(__dirname, '../../packages')
+
+const DistDir = path.join(__dirname, '../dist')
+const ZipsDir = path.join(DistDir, '/zips')
+const AssetsDir = path.join(DistDir, '/static')
+const EntriesDir = path.join(DistDir, '/entries')
+
+const TmpDir = path.join(DistDir, 'tmp')
+const PackagesJsonPath = path.join(DistDir, 'packages.json')
+
+const CdnInfoJson = JSON.parse(fs.readFileSync(path.join(__dirname, '../cdn.json')).toString())
+const PackagesJson = JSON.parse(fs.readFileSync(PackagesJsonPath).toString())
+console.log('Loaded existing checksums from', PackagesJsonPath)
+
+async function zipDirectory(sourceDir, outPath) {
+  return new Promise((resolve) => {
+    zip(sourceDir, outPath, { cwd: sourceDir }, (err) => {
+      console.log(`Zipped to ${outPath}`)
+      resolve(outPath)
+    })
+  })
+}
+
+const copyFileOrDir = (src, dest, exludedFilesGlob) => {
+  const isDir = fs.lstatSync(src).isDirectory()
+  if (isDir) {
+    ensureDirExists(dest)
+    const entries = fs.readdirSync(src, { withFileTypes: true })
+
+    for (const entry of entries) {
+      const srcPath = path.join(src, entry.name)
+
+      const excluded = exludedFilesGlob && minimatch(srcPath, exludedFilesGlob)
+      if (excluded) {
+        console.log('Excluding file', srcPath)
+        continue
+      }
+      const destPath = path.join(dest, entry.name)
+
+      entry.isDirectory() ? copyFileOrDir(srcPath, destPath) : fs.copyFileSync(srcPath, destPath)
+    }
+  } else {
+    const excluded = exludedFilesGlob && minimatch(src, exludedFilesGlob)
+    if (excluded) {
+      console.log('Excluding file', src)
+      return
+    }
+    fs.copyFileSync(src, dest)
+  }
+}
+
+const getComponentSrcPath = (feature) => {
+  return path.join(SourceFilesPath, feature.identifier)
+}
+
+const copyComponentAssets = async (feature, destination, exludedFilesGlob) => {
+  const srcComponentPath = getComponentSrcPath(feature)
+
+  if (!doesDirExist(srcComponentPath)) {
+    return false
+  }
+
+  emptyExistingDir(destination)
+  ensureDirExists(destination)
+
+  for (const file of feature.staticFiles) {
+    const srcFilePath = path.join(srcComponentPath, file)
+    if (!fs.existsSync(srcFilePath)) {
+      continue
+    }
+
+    const targetFilePath = path.join(destination, file)
+    copyFileOrDir(srcFilePath, targetFilePath, exludedFilesGlob)
+  }
+
+  return true
+}
+
+const computePackageZipChecksum = async (zipPath) => {
+  const zipData = fs.readFileSync(zipPath, 'base64')
+  const base64Hash = crypto.createHash('sha256').update(zipData).digest('hex')
+  const checksumProcess = spawn('sha256sum', [zipPath])
+  const checksumString = checksumProcess.stdout.toString()
+  const binaryHash = checksumString.split('  ')[0]
+
+  return {
+    base64Hash: base64Hash,
+    binaryHash: binaryHash,
+  }
+}
+
+const packageFeature = async ({ feature, noZip }) => {
+  console.log('Processing feature', feature.identifier, '...')
+
+  const assetsLocation = `${path.join(AssetsDir, feature.identifier)}`
+  const assetsSuccess = await copyComponentAssets(feature, assetsLocation, '**/package.json')
+  if (!assetsSuccess) {
+    console.log('Failed to copy assets for', feature.identifier)
+    return
+  }
+
+  if (noZip) {
+    console.log('Input arg noZip detected; not zipping asset.')
+    return
+  }
+
+  const zipAssetsTmpLocation = `${path.join(TmpDir, feature.identifier)}`
+  const zipAssetsSuccess = await copyComponentAssets(feature, zipAssetsTmpLocation)
+  if (!zipAssetsSuccess) {
+    console.log('Failed to copy zip assets for', feature.identifier)
+    return
+  }
+
+  const zipDestination = `${ZipsDir}/${feature.identifier}.zip`
+  await zipDirectory(zipAssetsTmpLocation, zipDestination)
+
+  const packageJsonFilePath = path.join(getComponentSrcPath(feature), 'package.json')
+  const packageJsonFile = JSON.parse(fs.readFileSync(packageJsonFilePath).toString())
+
+  const checksum = await computePackageZipChecksum(zipDestination, packageJsonFile.version)
+
+  const packageEntry = {
+    ...packageJsonFile.sn,
+    identifier: feature.identifier,
+    version: packageJsonFile.version,
+    url: `${CdnInfoJson.host}/static/${feature.identifier}/${packageJsonFile.sn.main}`,
+    download_url: `${CdnInfoJson.host}/zips/${feature.identifier}.zip`,
+    latest_url: `${CdnInfoJson.host}/entries/${feature.identifier}.json`,
+    publisher: packageJsonFile.author,
+    ...checksum,
+  }
+
+  PackagesJson[feature.identifier] = packageEntry
+
+  fs.writeFileSync(`${EntriesDir}/${feature.identifier}.json`, JSON.stringify(packageEntry, undefined, 2))
+
+  console.log(`Computed checksums for ${feature.identifier}:`, checksum)
+}
+
+await (async () => {
+  const args = process.argv[2] || ''
+  const noZip = args.includes('--no-zip')
+
+  let index = 0
+  for (const feature of Packages) {
+    if (index === 0) {
+      console.log('\n---\n')
+    }
+
+    await packageFeature({ feature, noZip })
+
+    if (index !== Packages.length - 1) {
+      console.log('\n---\n')
+    }
+
+    index++
+  }
+
+  fs.writeFileSync(PackagesJsonPath, JSON.stringify(PackagesJson, undefined, 2))
+  copyFileOrDir(PackagesJsonPath, PackagesJsonPath)
+
+  console.log('Succesfully wrote checksums to', PackagesJsonPath)
+
+  emptyExistingDir(TmpDir)
+
+  writePackageDirectoryToReadme()
+})()

package/scripts/Readme.mjs

@@ -0,0 +1,40 @@
+import path from 'path'
+import { fileURLToPath } from 'url'
+import { readJson, readFile, writeFile } from '../../scripts/ScriptUtils.mjs'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+const ROOT = path.join(__dirname, '../..')
+
+export function writePackageDirectoryToReadme() {
+  const packageEntries = readJson(path.join(ROOT, 'cdn/dist/packages.json'))
+  const packages = Object.values(packageEntries)
+
+  const template = readFile(path.join(ROOT, 'readme.template.md'))
+
+  const DirectoryPlaceholder = '<!-- DIRECTORY -->'
+
+  let directoryString = ``
+  directoryString += '| Name | Publisher | Install Link |'
+  directoryString += '\n'
+  directoryString += '|------|-----------|--------------|'
+
+  for (const packageEntry of packages) {
+    let string = '|'
+    string += `${packageEntry.name}`
+    string += '|'
+    string += `${packageEntry.publisher}`
+    string += '|'
+    string += `${packageEntry.latest_url}`
+    string += '|'
+    directoryString += '\n'
+
+    directoryString += string
+  }
+
+  const result = template.replace(DirectoryPlaceholder, directoryString)
+
+  writeFile(result, path.join(ROOT, 'README.md'))
+
+  console.log('Wrote README file', result)
+}