@notifiles/sdk 1.0.0

package/src/lib/cloudLibrary/minio/upload.js

@@ -0,0 +1,61 @@
+import * as Minio from 'minio'
+
+export default async ({
+  sourceUrl,
+  filename,
+  auth,
+  // contentType = 'image/png'
+}) => {
+
+  try {
+    const {
+      endPoint,
+      accessKey,
+      secretKey,
+      bucketName
+    } = auth
+
+    const minioClient = new Minio.Client({
+      endPoint,
+      // port,
+      // useSSL,
+      accessKey,
+      secretKey,
+    })
+
+    const destinationObject = filename
+
+    const exists = await minioClient.bucketExists(bucketName)
+    if (!exists) {
+      return null
+      // await minioClient.makeBucket(bucketName, 'us-east-1')
+      // console.log('Bucket ' + bucketName + ' created in "us-east-1".')
+    }
+
+    const metaData = {
+      // 'Content-Type': contentType,
+    }
+
+    const minioResult = await new Promise((resolve, reject) => {
+      minioClient.fPutObject(
+        bucketName,
+        destinationObject,
+        sourceUrl,
+        metaData,
+        (error, objInfo) => {
+          if (error) {
+            reject(error)
+            return
+          }
+
+          resolve(objInfo)
+        })
+    })
+    const url = `https://${endPoint}/${bucketName}/${filename}`
+    return { url }
+
+  } catch (e) {
+    console.error(e)
+  }
+  return null
+}

package/src/lib/cloudLibrary/minio/uploadFolder.js

@@ -0,0 +1,26 @@
+import { FsTree } from 'fs-tree-tool'
+import upload from './upload'
+
+export default async (props) => {
+  const {
+    path
+    // contentType = 'image/png'
+  } = props
+
+  try {
+    const tree = await FsTree.getDirectoryTree(path)
+
+  } catch (e) {
+    console.error(e)
+  }
+  return null
+}
+
+
+const uploadFolder = (props) => {
+  const { path } = props
+
+  return upload({
+    ...props,
+  })
+}

package/src/lib/entries/getAtPath.js

@@ -0,0 +1,105 @@
+import checkFileExists from '../fs/checkFileExists.js'
+import fs from 'fs'
+import fsPath from 'path'
+import _ from 'underscore'
+import isPathEntry from './isPathEntry.js'
+import importJSONAsync from "../fs/importJSONAsync.js"
+import slug from 'slug'
+import createActivityIfNeeded from '../../template/lib/activity/createFileIfNeeded.js'
+
+const perform = async (props) => {
+  const {
+    path,
+  } = props
+
+  try {
+    if (!(await checkFileExists(path))) {
+      return null
+    }
+
+    const items = await fs.promises.readdir(path)
+
+    if (!items || !items.length) {
+      return null
+    }
+
+    let results = (await Promise.all(items.map(async item => {
+
+      const folderPath = fsPath.join(path, item)
+
+      const folderPathStat = await fs.promises.stat(folderPath)
+      if (!folderPathStat) {
+        return null
+      }
+
+      const isDir = folderPathStat.isDirectory()
+      if (!isDir) {
+        return null
+      }
+
+      if (!(await isPathEntry({ path: folderPath }))) {
+        return perform({
+          ...props,
+          path: folderPath
+        })
+      }
+
+
+      let testMessagePath = fsPath.join(folderPath, 'textmessage.txt')
+      let pushPath = fsPath.join(folderPath, 'push.txt')
+      const i18nPath = fsPath.join(folderPath, 'i18n.json')
+      let manifest = await importJSONAsync(fsPath.join(folderPath, 'manifest.json'))
+
+      await createActivityIfNeeded({ path: folderPath })
+
+
+      let activity
+      const activityPath = fsPath.join(folderPath, '.activity.json')
+      if (await checkFileExists(activityPath)) {
+        activity = await importJSONAsync(activityPath)
+      }
+
+      // await createActivityIfNeeded({ path: folderPath })
+
+      // const module = await import(emailPath)
+      let textMessage = null
+      let push = null
+      let i18n = null
+
+      if (await checkFileExists(testMessagePath)) {
+        textMessage = await fs.promises.readFile(testMessagePath, 'utf8')
+      }
+
+      if (await checkFileExists(pushPath)) {
+        push = await fs.promises.readFile(pushPath, 'utf8')
+      }
+
+      if (await checkFileExists(i18nPath)) {
+        i18n = await importJSONAsync(i18nPath)
+      }
+
+
+      return [{
+        name: item,
+        slug: slug(item),
+        path: folderPath,
+        // email: module,
+        textMessage,
+        push,
+        i18n: i18n ? i18n : {},
+        manifest,
+        activity
+      }]
+
+    }))).filter(a => a)
+
+    results = _.flatten(results)
+    return results
+  }
+  catch (e) {
+    console.error(e)
+    return null
+  }
+}
+
+export default perform

package/src/lib/entries/isPathEntry.js

@@ -0,0 +1,29 @@
+import checkFileExists from '../fs/checkFileExists.js'
+import fs from 'fs'
+import fsPath from 'path'
+
+export default async (props) => {
+  const {
+    path,
+  } = props
+
+  if (!(await checkFileExists(path))) {
+    return false
+  }
+
+  const pathStat = await fs.promises.stat(path)
+  if (!pathStat) {
+    return false
+  }
+
+  const isDir = pathStat.isDirectory()
+  if (!isDir) {
+    return false
+  }
+
+  const postPath = fsPath.join(path, 'email.js')
+  const postPath2 = fsPath.join(path, 'email.tsx')
+
+  return ((await checkFileExists(postPath))
+    || (await checkFileExists(postPath2)))
+}

package/src/lib/entries.js

@@ -0,0 +1,144 @@
+import checkFileExists from './fs/checkFileExists.js'
+import fs from 'fs'
+import fsPath from 'path'
+import _ from 'underscore'
+import importJSONAsync from "./fs/importJSONAsync.js"
+import importYAMLAsync from "./fs/importYAMLAsync.js"
+import markdownToLexer from './remark/markdownToLexer.js'
+import createStatusIfNeeded from '../post/lib/activity/createFileIfNeeded.js'
+
+const perform = async (props) => {
+  const {
+    path,
+  } = props
+
+  try {
+    if (!(await checkFileExists(path))) {
+      return null
+    }
+
+    const items = await fs.promises.readdir(path)
+
+    if (!items || !items.length) {
+      return null
+    }
+
+    let results = (await Promise.all(items.map(async item => {
+
+      const folderPath = fsPath.join(path, item)
+
+      const folderPathStat = await fs.promises.stat(folderPath)
+      if (!folderPathStat) {
+        return null
+      }
+
+      const isDir = folderPathStat.isDirectory()
+      if (!isDir) {
+        return null
+      }
+
+      await createStatusIfNeeded({ path: folderPath })
+
+      const postPath = fsPath.join(folderPath, 'post.md')
+      const excerptPath = fsPath.join(folderPath, 'excerpt.md')
+      const postConsolidatedPath = fsPath.join(folderPath, '.post.consolidated.md')
+      const postBuiltPath = fsPath.join(folderPath, '.post.built.md')
+      const postOptimizedPath = fsPath.join(folderPath, '.post.optimized.md')
+      const postCloudPath = fsPath.join(folderPath, '.post.cloud.md')
+      const manifestPath = fsPath.join(folderPath, 'manifest.yaml')
+      const statusPath = fsPath.join(folderPath, '.activity.json')
+
+      if (!(await checkFileExists(postPath))
+        || !(await checkFileExists(manifestPath))
+      ) {
+        return perform({
+          ...props,
+          path: folderPath
+        })
+      }
+
+      const post = await fs.promises.readFile(postPath, 'utf8')
+      const postMdast = markdownToLexer({
+        data: post
+      })
+
+      const manifest = await importYAMLAsync(manifestPath)
+      if (manifest.skip) {
+        return null
+      }
+
+      let postConsolidated = null
+      let postConsolidatedMdast = null
+      let postBuilt = null
+      let postOptimized = null
+      let postCloud = null
+      let postBuiltMdast = null
+      let excerpt = null
+      let status = null
+
+      if (await checkFileExists(postConsolidatedPath)) {
+        postConsolidated = await fs.promises.readFile(postConsolidatedPath, 'utf8')
+        postConsolidatedMdast = markdownToLexer({
+          data: postConsolidated
+        })
+      }
+
+      if (await checkFileExists(postBuiltPath)) {
+        postBuilt = await fs.promises.readFile(postBuiltPath, 'utf8')
+        postBuiltMdast = markdownToLexer({
+          data: postBuilt
+        })
+      }
+
+      if (await checkFileExists(excerptPath)) {
+        excerpt = await fs.promises.readFile(excerptPath, 'utf8')
+      }
+
+      if (await checkFileExists(postOptimizedPath)) {
+        postOptimized = await fs.promises.readFile(postOptimizedPath, 'utf8')
+      }
+
+      if (await checkFileExists(postCloudPath)) {
+        postCloud = await fs.promises.readFile(postCloudPath, 'utf8')
+      }
+
+      if (await checkFileExists(statusPath)) {
+        status = await importJSONAsync(statusPath, 'utf8')
+      }
+
+      return [{
+        path: folderPath,
+        excerpt,
+        post,
+        postMdast,
+        postBuilt,
+        postBuiltMdast,
+        postConsolidated,
+        postConsolidatedMdast,
+        postCloud,
+        postOptimized,
+        manifest,
+        status,
+        post: {
+          source: post,
+          mdast: postMdast,
+          built: postBuilt,
+          consolidated: postConsolidated,
+          consolidatedMdast: postConsolidatedMdast,
+          cloud: postCloud,
+          optimized: postOptimized
+        }
+      }]
+
+    }))).filter(a => a)
+
+    results = _.flatten(results)
+    return results
+  }
+  catch (e) {
+    console.error(e)
+    return null
+  }
+}
+
+export default perform

package/src/lib/fs/checkFileExists.js

@@ -0,0 +1,6 @@
+import fs from 'fs'
+export default async (file) => {
+    return fs.promises.access(file, fs.constants.F_OK)
+        .then(() => true)
+        .catch(() => false)
+}

package/src/lib/fs/directoryFilesRecursive.js

@@ -0,0 +1,83 @@
+import checkFileExists from './checkFileExists.js'
+import fs from 'fs'
+import fsPath from 'path'
+import _ from 'underscore'
+//https://www.npmjs.com/package/directory-import
+
+
+const perform = async ({ path,
+  includeMeta = false,
+  excludes = ['spec.js'],
+  includeExtensions = ['.js', '.ts', '.json']
+}) => {
+  try {
+    if (!(await checkFileExists(path))) {
+      return null
+    }
+
+    const items = await fs.promises.readdir(path)
+
+    if (!items || !items.length) {
+      return null
+    }
+
+    let results = (await Promise.all(items.map(async item => {
+
+
+      const __path = fsPath.join(path, item)
+
+      const _stat = await fs.promises.stat(__path)
+      if (!_stat) {
+        return null
+      }
+
+      const isDir = _stat.isDirectory()
+      if (isDir) {
+        return perform({ path: __path })
+      }
+
+      if (!(await checkFileExists(__path))) {
+        return null
+      }
+
+      if (item.includes('spec.js')) {
+        return null
+      }
+      const extension = getExtension(item)
+      if (!includeExtensions.includes(extension)) {
+        return null
+      }
+
+      if (includeMeta) {
+        const racine = getFileRaw(__path)
+        const _module = await import(__path)
+        const md = `${racine}.md`
+        let documentation = null
+        if ((await checkFileExists(md))) {
+          documentation = await fs.promises.readFile(md, 'utf8')
+        }
+
+        return [{
+          module: _module,
+          path: __path,
+          documentation
+        }]
+      } else {
+        return [(await import(__path))]
+      }
+    }))).filter(a => a)
+
+    results = _.flatten(results)
+    return results
+  }
+  catch (e) {
+    console.error(e)
+    return null
+  }
+}
+
+const getExtension = str => str.slice(str.lastIndexOf("."))
+const getFileRaw = str => str.split('.').slice(0, -1).join('.')
+
+
+export default perform

package/src/lib/fs/ensureDirectoryExists.js

@@ -0,0 +1,10 @@
+import fs from 'fs'
+
+export default async (filePath, stripFileName = true) => {
+  try {
+    await fs.promises.mkdir(filePath)
+    return true
+  } catch (e) {
+    return false
+  }
+}

package/src/lib/fs/getFileCallerURL.js

@@ -0,0 +1,12 @@
+export default () => {
+  const error = new Error()
+  const stack = error.stack?.split('\n')
+  const data = stack[3]
+  const filePathPattern = new RegExp(`(file:[/]{2}.+[^:0-9]):{1}[0-9]+:{1}[0-9]+`)
+  const result = filePathPattern.exec(data)
+  let filePath = ''
+  if (result && (result.length > 1)) {
+    filePath = result[1]
+  }
+  return filePath
+}

package/src/lib/fs/importFileAsText.js

@@ -0,0 +1,15 @@
+import fs from "fs"
+import checkFileExists from "./checkFileExists.js"
+
+export default async _url => {
+  try {
+    if (!(await checkFileExists(_url))) {
+      return null
+    }
+    const fileUrl = new URL(_url, import.meta.url)
+    return fs.promises.readFile(fileUrl, 'utf8')
+  } catch (e) {
+    console.log("[notifiles]", `importFileAsText → `, e)
+    return null
+  }
+}

package/src/lib/fs/importJSONAsync.js

@@ -0,0 +1,16 @@
+import fs from "fs"
+import checkFileExists from "./checkFileExists.js"
+
+export default async _url => {
+  // try {
+  if (!(await checkFileExists(_url))) {
+    return null
+  }
+  const fileUrl = new URL(_url, import.meta.url)
+  const parsedPackageJSON = JSON.parse(await fs.promises.readFile(fileUrl, 'utf8'))
+  return parsedPackageJSON
+  // } catch (e) {
+  //   console.log("[notifiles]", `importJSONAsync → `, e)
+  //   return null
+  // }
+}

package/src/lib/fs/importYAMLAsync.js

@@ -0,0 +1,14 @@
+import fs from "fs"
+import checkFileExists from "./checkFileExists.js"
+import YAML from 'yaml'
+
+export default async _url => {
+  if (!(await checkFileExists(_url))) {
+    return null
+  }
+  const fileUrl = new URL(_url, import.meta.url)
+  const file = fs.readFileSync(fileUrl, 'utf8')
+
+  const parsed = YAML.parse(file)
+  return parsed
+}

package/src/lib/remark/hastToHtml.js

@@ -0,0 +1,6 @@
+import { toHtml } from 'hast-util-to-html'
+
+export default ({ data } = {}) => {
+  const html = toHtml(data)
+  return html
+}

package/src/lib/remark/htmlToHast.js

@@ -0,0 +1,6 @@
+import { fromHtml, } from 'hast-util-from-html'
+
+export default ({ data } = {}) => {
+  const hast = fromHtml(data, { fragment: true })
+  return hast
+}

package/src/lib/remark/htmlToMarkdown copy.js

@@ -0,0 +1,12 @@
+import { unified } from 'unified'
+import stringify from 'remark-stringify'
+import rehypeParse from 'rehype-parse'
+import rehype2remark from 'rehype-remark'
+
+export default async ({ data } = {}) => {
+  const processor = unified()
+    .use(rehypeParse)
+    .use(rehype2remark)
+    .use(stringify)
+  return processor.process(data)
+}

package/src/lib/remark/htmlToMarkdown.js

@@ -0,0 +1,23 @@
+import { fromHtml } from 'hast-util-from-html'
+import { toMdast } from 'hast-util-to-mdast'
+import { toMarkdown } from 'mdast-util-to-markdown'
+
+export default async ({ data } = {}) => {
+  const hast = fromHtml(data, { fragment: true })
+  const mdast = toMdast(hast)
+  const markdown = toMarkdown(mdast)
+  return markdown
+}
+
+
+// import fs from 'node:fs/promises'
+// import {fromHtml} from 'hast-util-from-html'
+// import {toMdast} from 'hast-util-to-mdast'
+// import {toMarkdown} from 'mdast-util-to-markdown'
+
+// const html = String(await fs.readFile('example.html'))
+// const hast = fromHtml(html, {fragment: true})
+// const mdast = toMdast(hast)
+// const markdown = toMarkdown(mdast)
+
+// console.log(markdown)

package/src/lib/remark/htmlToMdast.js

@@ -0,0 +1,13 @@
+import htmlToMarkdown from "./htmlToMarkdown.js"
+import markdownToLexer from "./markdownToLexer.js"
+
+export default async ({ data } = {}) => {
+  const file = await htmlToMarkdown({ data })
+  if (!file) {
+    return null
+  }
+
+  const md = String(file)
+  const lexer = markdownToLexer({ data: md })
+  return lexer
+}

package/src/lib/remark/htmlToMdast_.js

@@ -0,0 +1,21 @@
+import { fromHtml, } from 'hast-util-from-html'
+import { toMdast } from 'hast-util-to-mdast'
+
+export default async ({ data } = {}) => {
+  const hast = fromHtml(data, { fragment: true })
+  const mdast = toMdast(hast)
+  return mdast
+}
+
+
+// import fs from 'node:fs/promises'
+// import {fromHtml} from 'hast-util-from-html'
+// import {toMdast} from 'hast-util-to-mdast'
+// import {toMarkdown} from 'mdast-util-to-markdown'
+
+// const html = String(await fs.readFile('example.html'))
+// const hast = fromHtml(html, {fragment: true})
+// const mdast = toMdast(hast)
+// const markdown = toMarkdown(mdast)
+
+// console.log(markdown)

package/src/lib/remark/htmlToMdast_3.js

@@ -0,0 +1,21 @@
+import { fromHtml } from 'hast-util-from-html'
+import { toMdast } from 'hast-util-to-mdast'
+
+export default async ({ data } = {}) => {
+  const hast = fromHtml(data, { fragment: true })
+  const mdast = toMdast(hast)
+  return mdast
+}
+
+
+// import fs from 'node:fs/promises'
+// import {fromHtml} from 'hast-util-from-html'
+// import {toMdast} from 'hast-util-to-mdast'
+// import {toMarkdown} from 'mdast-util-to-markdown'
+
+// const html = String(await fs.readFile('example.html'))
+// const hast = fromHtml(html, {fragment: true})
+// const mdast = toMdast(hast)
+// const markdown = toMarkdown(mdast)
+
+// console.log(markdown)

package/src/lib/remark/markdownToHTML.js

@@ -0,0 +1,22 @@
+
+import rehypeStringify from 'rehype-stringify'
+import remarkGfm from 'remark-gfm'
+import remarkParse from 'remark-parse'
+import remarkRehype from 'remark-rehype'
+import { unified } from 'unified'
+
+
+export default async ({
+  data,
+} = {}) => {
+
+  const file = await unified()
+    .use(remarkParse)
+    .use(remarkGfm)
+    .use(remarkRehype)
+    .use(rehypeStringify)
+    .process(data)
+
+
+  return String(file)
+}

package/src/lib/remark/markdownToLexer.js

@@ -0,0 +1,19 @@
+import { unified } from 'unified'
+import remarkParse from 'remark-parse'
+
+export default ({ data } = {}) => {
+  const tokens = unified()
+    .use(remarkParse, { gfm: true })
+    .parse(data)
+
+
+
+  // const _tokens = unified()
+  //   .use(remarkParse)
+  //   .use(remarkGfm)
+  //   .parse(data)
+
+  // const a = mdastToHTML({ mdast: _tokens })
+
+  return tokens
+}