@hhgtech/hhg-components 1.19.0-beta-6 → 1.19.0-beta-7

package/raw/together/utils/post.ts

@@ -1,351 +0,0 @@
-import { ADMIN_PATHS, PATHS } from '../api/paths'
-import { callApiWithAdminAuth, callApiWithAuth, getApiPath } from '../api/utils'
-
-export const EncodeUrlRegexMap = {
-  edit: /<mocka ([^>]*)data-url="true"[^<>]*>(.*?)<\/mocka>/gim,
-  url: /((?:=")|(?:data-url="true">)|)(https?:\/\/(www\.)?(?:\([-A-Z0-9+&@#\/%=~_|$?!:,.]*\)|[-A-Z0-9+&@#\/%=~_|$?!:,.])*(?:\([-A-Z0-9+&@#\/%=~_|$?!:,.]*\)|[A-Z0-9+&@#\/%=~_|$]))/gim,
-  encodedUrl: /\[a\+href="([^<"]+)"(?:\+text=\"([^<"]+)")?\]/gim,
-  editorMention: /<mention [^>]*data-id="([^<"]+)"[^>]*>([^<]+)<\/mention>/gim,
-  editorFullMention:
-    /<mention [^>]*data-id="([^<"]+)" [^\>]*data-name="([^<"]+)"[^>]*>([^<]+)<\/mention>/gim,
-  savedMention: /\[mention\+id="([^<"]+)"([^\]]*)\]/gim,
-  rawUrl:
-    /^(https?:\/\/(www\.)?(?:\([-A-Z0-9+&@#\/%=~_|$?!:,.]*\)|[-A-Z0-9+&@#\/%=~_|$?!:,.])*(?:\([-A-Z0-9+&@#\/%=~_|$?!:,.]*\)|[A-Z0-9+&@#\/%=~_|$]))$/gim,
-  optionalProtocol:
-    /^((https?:\/\/)?(www\.)?(?:\([-A-Z0-9+&@#\/%=~_|$?!:,.]*\)|[-A-Z0-9+&@#\/%=~_|$?!:,.])*(?:\([-A-Z0-9+&@#\/%=~_|$?!:,.]*\)|[A-Z0-9+&@#\/%=~_|$]))$/gim,
-  encodedUrl2: /<a [^>]*href="([^>"]+)"[^>]*>([^<]+)<\/a>/gim,
-}
-export const BadWordRegex =
-  /<mocka [^\>]*data-bad-word="[^\"]*" [^\>]*data-error="true"[^\>]*>(.*?)<\/mocka>/gim
-export const encodePostUrl = (s: string, sanitizeFunction = (s: string) => s) =>
-  sanitizeFunction(
-    s
-      .replace(/(\&nbsp;)+/g, ' ')
-      .replace(/(\&amp;)+/g, '&')
-      ?.replace(/(\u200c|&zwnj;)+/g, '')
-      .replace(EncodeUrlRegexMap.url, (match, p1, p2) => {
-        if (p1 !== '="' && p1 !== 'data-url="true">')
-          return `<a href="${p2}" target="_blank">${p2}</a>`
-        return match
-      })
-      .replace(EncodeUrlRegexMap.edit, (match, p1, p2) => {
-        const cleanUrl = p1.match(/data-href="([^"]*)"/im)?.[1]
-        if (cleanUrl) return `<a href="${cleanUrl}" target="_blank">${p2}</a>`
-        return `<a href="${p2}" target="_blank">${p2}</a>`
-      }),
-  )
-export const encodeMention = (s: string) =>
-  s.replace(EncodeUrlRegexMap.editorMention, (match, p1, p2) => {
-    return `[mention+id="${p1}"+name="${p2}"]`
-  })
-
-export const getAnchorHtml = ({
-  url,
-  text,
-  method,
-}: {
-  url: string
-  text: string
-  method: string
-}) => {
-  // remove white space before and after link element, put them outside of current tag
-  const trimStartIndex = text.indexOf(text.trimStart())
-  const trimEndIndex = text.trimEnd().length
-  const preSpaces = text.substring(0, trimStartIndex)
-  const trimmedText = text.substring(trimStartIndex, trimEndIndex)
-  const postSpaces = text.substring(trimEndIndex)
-  if (method === 'edit') {
-    return `${preSpaces}<mocka data-href="${url}" data-url="true">${trimmedText}</mocka>${postSpaces}`
-  }
-  if (method === 'display') {
-    if (url.startsWith('http://') || url.startsWith('https://')) {
-      return `${preSpaces}<a href="${url}" target="_blank">${trimmedText}</a>${postSpaces}`
-    }
-  }
-  return text
-}
-
-export const decodePostUrl = (s: string, method: string) =>
-  s
-    .replace(EncodeUrlRegexMap.encodedUrl, (match, p1, p2) => {
-      const text = p2 || p1
-      return getAnchorHtml({
-        text,
-        url: p1,
-        method,
-      })
-    })
-    .replace(EncodeUrlRegexMap.encodedUrl2, (match, p1, p2) => {
-      const text = p2 || p1
-      return getAnchorHtml({
-        text,
-        url: p1,
-        method,
-      })
-    })
-export const decodeMention = (
-  s: string,
-  users: {
-    id: number
-    name: string
-  }[] = [],
-) =>
-  s.replace(EncodeUrlRegexMap.savedMention, (match, p1, p2) => {
-    const foundUser = users.find((u) => String(u.id) === p1)
-    if (!foundUser) {
-      if (!p2) return ''
-      let tempName = ''
-      ;(p2 as string).replace(/\+name="([^<"]+)"/i, (m, _p1) => {
-        tempName = _p1
-        return m
-      })
-      return `<mention data-id="${p1}" data-name="${tempName}">${tempName}</mention>`
-    }
-    return `<mention data-id="${p1}" data-name="${foundUser.name}">${foundUser.name}</mention>`
-  })
-
-export const getUrlsFromString = (s: string) => {
-  const res: string[] = []
-  s.replace(/(\&amp;)+/g, '&').replace(
-    EncodeUrlRegexMap.url,
-    (match, p1, p2) => {
-      if (p1 !== '="' && p1 !== 'data-url="true">') {
-        res.push(p2)
-      }
-      return match
-    },
-  )
-  return res
-}
-export const LIMIT_MENTION = 30
-
-export const getMentionIdsFromString = (s: string, disableLimit?: boolean) => {
-  const res: string[] = []
-  s.replace(EncodeUrlRegexMap.editorMention, (match, p1) => {
-    res.push(p1)
-    return match
-  }).replace(EncodeUrlRegexMap.savedMention, (match, p1) => {
-    res.push(p1)
-    return match
-  })
-  if (!disableLimit) {
-    return Array.from(new Set(res)).slice(0, LIMIT_MENTION)
-  }
-  return res
-}
-export const getUrlsFromEditorString = (s: string): string[] =>
-  [
-    ...getUrlsFromString(s),
-    ...(s.match(EncodeUrlRegexMap.edit)?.map((s) => {
-      const cleanUrl = s.match(/data-href="([^"]*)"/im)?.[1]
-      const text = s.match(/>(.*?)<\/mocka>/im)?.[1]
-      return cleanUrl || text
-    }) || []),
-  ].filter((s) => !!s) as string[]
-
-export const escapeRegExp = (string: string) => {
-  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') // $& means the whole matched string
-}
-
-export function escapeHtmlString(html: string, isAttribute?: boolean) {
-  const escape = document.createElement('textarea')
-  if (!isAttribute) {
-    escape.textContent = html
-    return escape.innerText
-  } else {
-    escape.setAttribute('_temp', html)
-    return escape.getAttribute('_temp')
-  }
-}
-
-export function unescapeHtmlString(html: string) {
-  const escape = document.createElement('textarea')
-  escape.innerHTML = html
-  return escape.textContent
-}
-
-export const wrapAnchorAroundUrls = (s: string) =>
-  s
-    .replace(/(\&nbsp;)+/g, ' ')
-    // ?.replace(/(\&amp;)+/g, '&')
-    ?.replace(/(\u200c|&zwnj;)+/g, '')
-    ?.replace(EncodeUrlRegexMap.edit, (match, p1, p2) => {
-      const cleanUrl = p1.match(/data-href="([^"]*)"/im)?.[1]
-      if (!cleanUrl || cleanUrl === p2 || p2.match(EncodeUrlRegexMap.rawUrl))
-        return p2
-      if (cleanUrl) return `<a href="${cleanUrl}">${p2}</a>`
-      return `<a href="${p2}">${p2}</a>`
-    })
-    .replace(EncodeUrlRegexMap.url, (match, p1, p2) => {
-      if (p1 !== '="' && p1 !== 'data-url="true">') {
-        const lowercase = p2.toLowerCase()
-        const addHttps = !lowercase.startsWith('http') ? ' https://' : ''
-        const url = `${addHttps}${lowercase}`
-        return getAnchorHtml({
-          text: url,
-          url: url,
-          method: 'edit',
-        })
-      }
-      return match
-    })
-    .replace(EncodeUrlRegexMap.encodedUrl2, (match, p1, p2) => {
-      const text = p2 || p1
-      return getAnchorHtml({
-        text: text,
-        url: p1,
-        method: 'edit',
-      })
-    })
-
-export const removeEdittedBannedWord = (s: string) =>
-  s.replace(BadWordRegex, (s, m1) => {
-    const w = document.createElement('div')
-    w.innerHTML = s
-    const child = w.firstChild as HTMLElement
-    if (child?.innerText !== child?.getAttribute('data-bad-word')) return m1
-    else return s
-  })
-export const removeBannedWordWrapper = (s: string) =>
-  s.replace(BadWordRegex, '$1')
-export const removeFontFormat = (s: string) =>
-  s.replace(/<font [^\>]*>(.+)<\/font>/gim, (s, m1) => {
-    return m1.replace(/<u[^\>]*>(.+)<\/u>/gim, '$1')
-  })
-
-export const encodePostContent = (
-  s: string,
-  sanitizeFunction = (s: string) => s,
-) => encodePostUrl(encodeMention(removeBannedWordWrapper(s)), sanitizeFunction)
-
-export const ALLOW_DOMAIN_URL = [
-  'hellobacsi.com',
-  'hellosehat.com',
-  'hellodoktor.com',
-  'hellokrupet.com',
-  'hellodoctor.com.ph',
-  'hellokhunmor.com',
-  'hellosayarwon.com',
-  'helloyishi.com.tw',
-  'helloswasthya.com',
-  'marrybaby.vn',
-]
-
-export const reformatUrl = (s: string) => {
-  if (s.match(EncodeUrlRegexMap.optionalProtocol)) {
-    if (s.startsWith('https://') || s.startsWith('http://')) return s
-    else return `https://${s}`
-  }
-  return ''
-}
-
-export const highlightBadWords = (text: string, bannedWords: string[]) => {
-  const filteredBanedWords = bannedWords.filter(Boolean)
-  if (text && filteredBanedWords.length > 0) {
-    const submitTitle = removeBannedWordWrapper(text)
-    return submitTitle.replace(
-      new RegExp(
-        `\\b(${filteredBanedWords
-          .map((banned) => escapeRegExp(banned))
-          .join('|')})\\b`,
-        'gi',
-      ),
-      (s, m1) => {
-        const escape = document.createElement('mocka')
-        escape.setAttribute('data-bad-word', m1)
-        escape.setAttribute('data-error', 'true')
-        escape.innerText = m1
-        return `${escape.outerHTML}`
-      },
-    )
-  }
-  return text
-}
-
-export const fixMalformedMention = (text: string) => {
-  return text.replace(
-    EncodeUrlRegexMap.editorFullMention,
-    (match, id: string, originalName: string, nameText: string) => {
-      if (nameText !== originalName) {
-        // fix logic here
-        const splittedName = originalName.split(' ')
-        const cutoffIndex = splittedName.findIndex((_, index) => {
-          const nameSection = splittedName.slice(0, index + 1).join(' ')
-          if (nameText.startsWith(nameSection)) {
-            return false
-          }
-          return true
-        })
-        if (cutoffIndex === 0) return `@${nameText}`
-        else {
-          const nameSection = (
-            cutoffIndex < 0 ? splittedName : splittedName.slice(0, cutoffIndex)
-          ).join(' ')
-          const restText = nameText.slice(nameSection.length).trim()
-          console.log(cutoffIndex, nameSection, restText)
-          return `<mention data-id="${id}" data-name="${nameSection}">${nameSection}</mention> ${restText} `
-        }
-      }
-      return match
-    },
-  )
-}
-
-export const youtubeVidIdGetter = (url: string) => {
-  const regExp =
-    /(?:youtube(?:-nocookie)?\.com\/(?:[^\/]+\/.+\/|(?:v|e(?:mbed)?)\/|.*[?&]v=)|youtu\.be\/)([^"&?\/\s]+)/gi
-  let res = ''
-  url.replace(regExp, (...params) => {
-    res = params[1] || ''
-    return ''
-  })
-  return res || ''
-}
-export const facebookVidIdGetter = (url: string) => {
-  const regExp =
-    /(?:https?:\/\/)?(?:www.|web.|m.)?facebook.com\/(?:video.php|photo.php|watch)?\/?\?v=(\d+)|\S+\/videos\/((\S+)\/(\d+)|(\d+))\/?/gim
-  let res = ''
-  url.replace(regExp, (...params) => {
-    res = params.find((p) => p && /^\d+$/.test(p))
-    return ''
-  })
-  return res
-}
-
-export const uploadAndGetSrc = (
-  file: File | string,
-  locale: string,
-  isAdmin?: boolean,
-): Promise<string> =>
-  typeof file === 'string'
-    ? Promise.resolve(file)
-    : (async () => {
-        const imageFormData = new FormData()
-        if (file.type.startsWith('image/gif')) {
-          imageFormData.append('image', file)
-        } else {
-          const imageCompression = await import('browser-image-compression')
-          const compressed = await imageCompression.default(file, {
-            maxSizeMB: 0.4,
-            maxWidthOrHeight: 1536,
-            useWebWorker: true,
-          })
-          imageFormData.append('image', compressed)
-        }
-        const callApiFunction = isAdmin ? callApiWithAdminAuth : callApiWithAuth
-        const imageRes = await callApiFunction(
-          getApiPath(
-            isAdmin
-              ? ADMIN_PATHS.COMMENT.IMAGE_UPLOAD
-              : PATHS.COMMENT.IMAGE_UPLOAD,
-            {
-              _locale: locale,
-            },
-          ),
-          'POST',
-          {
-            data: imageFormData,
-          },
-        )
-        return imageRes?.data?.image || ''
-      })()