@icij/murmur-next 4.0.0

package/lib/styles/mixins.scss

@@ -0,0 +1,37 @@
+@mixin keyframes($animationName) {
+  @-webkit-keyframes #{$animationName} {
+    @content;
+  }
+  @-moz-keyframes #{$animationName} {
+    @content;
+  }
+  @-o-keyframes #{$animationName} {
+    @content;
+  }
+  @keyframes #{$animationName} {
+    @content;
+  }
+}
+
+@mixin animation($animation) {
+  -webkit-animation:$animation;
+  -moz-animation:$animation;
+  -o-animation:$animation;
+  animation:$animation;
+}
+
+@mixin animation-delay-loop($from:0, $to:10, $delay: 300ms) {
+  @for $i from $from through $to {
+      &:nth-child(#{$i}) {
+        animation-delay: $i * $delay;
+      }
+  }
+}
+
+@mixin vendor-prefix($name, $argument) {
+  -webkit-#{$name}: #{$argument};
+  -ms-#{$name}: #{$argument};
+  -moz-#{$name}: #{$argument};
+  -o-#{$name}: #{$argument};
+  #{$name}: #{$argument};
+}

package/lib/styles/utilities.scss

@@ -0,0 +1,18 @@
+.text-jumbotron {
+  font-family: $jumbotron-font-family;
+  font-weight: $jumbotron-font-weight;
+}
+
+.text-sans-serif {
+  font-family: $font-family-sans-serif;
+}
+
+.text-serif {
+  font-family: $font-family-serif;
+}
+
+.jumbotron > h1,
+.jumbotron > .h1 {
+  font-family: $jumbotron-font-family;
+  font-weight: $jumbotron-font-weight;
+}

package/lib/styles/variables.scss

@@ -0,0 +1,94 @@
+$white:    #fff !default;
+$gray-100: #f8f8f8 !default;
+$gray-200: #e9e9e9 !default;
+$gray-300: #dedede !default;
+$gray-400: #cccccc !default; // Brand color
+$gray-500: #999999 !default; // Brand color
+$gray-600: #696969 !default; // Brand color
+$gray-700: #494949 !default;
+$gray-800: #3c3c3c !default; // Brand color
+$gray-900: #212121 !default;
+$black:    #000 !default;
+
+$primary: #ff0000 !default;  // Brand color
+$secondary: $gray-500 !default;
+$danger: #8B0707 !default; // Brand color
+$success: #46EC4E !default;
+$info: #0000FF !default;
+$warning: #FFBA00 !default;
+$light: $gray-200 !default;
+$dark: #000 !default;
+
+$brand-grays: () !default;
+$brand-grays: map-merge(
+  (
+    "gray-lighter": $gray-400,
+    "gray-light":   $gray-500,
+    "gray-dark":    $gray-600,
+    "gray-darker":  $gray-800
+  ),
+  $brand-grays
+);
+
+$body-bg: $white !default;   // Brand color
+$body-color: $black !default;  // Brand color
+$text-muted: $gray-500 !default;
+
+$component-active-bg: $primary !default;
+$component-active-color: $white;
+
+$table-dark-bg: $gray-800 !default;
+$table-dark-border-color: $gray-600 !default;
+
+$enable-rounded: false !default;
+$enable-shadows: true !default;
+$enable-gradients: false !default;
+
+$font-family-sans-serif: "Poppins", -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif !default;
+$font-family-serif: "Merriweather", Georgia, "Times New Roman", Times, serif !default;
+
+$headings-font-family: $font-family-sans-serif !default;
+$headings-font-weight: 700 !default;
+
+$jumbotron-bg: $gray-200 !default;
+$jumbotron-font-family: "Anton", $font-family-sans-serif !default;
+$jumbotron-font-weight: 400 !default;
+
+$fade-bg: $gray-400 !default;
+$list-group-bg: transparent !default;
+
+$input-focus-border-color: $secondary !default;
+$bs-input-bg: $gray-100 !default;
+$input-focus-bg: $white !default;
+$input-box-shadow: none !default;
+
+$btn-box-shadow: none !default;
+$btn-font-family: $font-family-sans-serif;
+
+$form-check-input-gutter: 1.5rem !default;
+
+$popover-body-padding-y: 0 !default;
+$popover-body-padding-x: 0 !default;
+$popover-max-width: 300px !default;
+
+$popover-box-shadow: 0 10px 30px -5px rgba($black, 0.15) !default;
+$dropdown-box-shadow: $popover-box-shadow !default;
+$dropdown-min-width: 14rem;
+
+$modal-backdrop-bg: $white !default;
+$modal-lg: 990px !default;
+$modal-content-box-shadow-xs: $popover-box-shadow !default;
+$modal-content-box-shadow-sm-up: $popover-box-shadow !default;
+
+$tooltip-max-width: 260px !default;
+$tooltip-opacity: 1 !default;
+
+$alert-border-width: 0;
+
+// Bootstrap variables and functions must be available everywhere
+@import 'node_modules/bootstrap/scss/_functions.scss';
+@import 'node_modules/bootstrap/scss/_variables.scss';
+
+// Get theses variables to make them available in the doc
+$theme-colors: none !default;
+$font-family-monospace: none !default;

package/lib/styles/variables_dark.scss

@@ -0,0 +1 @@
+$bs-input-bg-dark: $gray-900 !default;

package/lib/types.ts

@@ -0,0 +1,46 @@
+import type { StyleValue } from 'vue'
+
+import {AccordionKey, ParentKey} from '@/keys'
+import { ComputedRef } from 'vue'
+import type { GeoProjection } from 'd3-geo'
+import { Ref } from 'vue'
+
+
+export type Step = symbol | string
+
+export type Accordion = {
+  emitAccordionNextStepEvent: () => void
+  emitAccordionPreviousStepEvent: () => void
+  isActiveStep: (step: Step) => boolean
+  isPreviousStep: (step: Step) => boolean
+  isFirstStep: (step: Step) => boolean
+  isLastStep: (step: Step) => boolean
+  step: Step
+  steps: Step[]
+}
+
+export type AccordionProvide = {
+  [AccordionKey]: Accordion
+}
+
+export type BrandStyle = StyleValue & {
+  '--monochrome-color': string
+  color: string
+  background: string
+  width: string
+}
+
+export type BrandExpansionStyle = Pick<BrandStyle, '--monochrome-color' | 'background'>
+
+export type Variant = 'primary' | 'secondary' | 'danger' | 'info' | 'warning' | 'success' | 'dark' | 'light'
+
+export type MapTransform = { k: number, x: number, y: number, rotateX: number, rotateY : number }
+
+export type ParentMap = {
+  mapRect:Ref<DOMRect>,
+  mapTransform:Ref<MapTransform>,
+  rotatingMapProjection:ComputedRef<GeoProjection|Function>
+}
+export type ParentMapProvide = {
+  [ParentKey]: ParentMap
+}

package/lib/utils/animation.ts

@@ -0,0 +1,24 @@
+export class RequestAnimationFrameWrapper {
+  live: boolean
+  callback: () => void
+
+  constructor () {
+    this.live = false
+    this.callback = () => null
+  }
+  start (callback: () => void) {
+    this.live = true
+    this.callback = callback
+    this.schedule()
+  }
+  stop () {
+    this.live = false
+    this.callback = () => null
+  }
+  schedule () {
+    this.callback()
+    if (this.live) {
+      window.requestAnimationFrame(this.schedule.bind(this))
+    }
+  }
+}

package/lib/utils/assets.ts

@@ -0,0 +1,46 @@
+import { memoize, flatten } from 'lodash'
+
+var assetUniqueIdCounter: number = 0;
+
+export const injectAsset = memoize(function(file: string, id: string = `dynamic-asset-${assetUniqueIdCounter++}`): Promise<unknown> {
+  
+  return new Promise((resolve: (value?: unknown) => void) => {
+    const parent: HTMLElement = document.querySelector("body") || document.querySelector("head")!
+    const parts = file.split(".");
+    const ext = parts[parts.length-1].toLowerCase();
+    switch(ext) {
+      case "js":
+        var script = document.createElement('script');
+        script.setAttribute("type", "text/javascript");
+        script.onload = resolve
+        parent.appendChild(script);
+        script.setAttribute("src", file);
+        script.setAttribute("id", id);
+      break;
+      case "css":
+        var css = document.createElement('link');
+        css.setAttribute("rel", "stylesheet");
+        css.setAttribute("type", "text/css");
+        css.onload = resolve
+        parent.appendChild(css);
+        css.setAttribute("href", file);
+        css.setAttribute("id", id);
+      break;
+    }
+  })
+})
+
+export const injectAssets = function(...args: string[]): Promise<void> {
+  const files = flatten(args)
+  return new Promise((resolve: () => void) => {
+    var filesLoaded = 0;
+    var allFilesLoaded = function() {
+      if(++filesLoaded == files.length) {
+        resolve();
+      }
+    }
+    for(var i=0; i < files.length ; i++) {
+      injectAsset(files[i]).then(allFilesLoaded)
+    }
+  })
+}

package/lib/utils/clipboard.ts

@@ -0,0 +1,41 @@
+import Clipboard from 'clipboard'
+
+export function copyText (text: string, container: Element): Promise<void> {
+  return new Promise(function (resolve: (value?:undefined) => void, reject: (value?: Clipboard.Event) => void) {
+    const fakeElement = document.createElement('button')
+    // Use the document body as container is no valid object is provided
+    container = typeof container === 'object' ? container : document.body
+
+    const clipboard: Clipboard = new Clipboard(fakeElement, { text: () => text, container })
+
+    clipboard.on('success', () => {
+      clipboard.destroy()
+      resolve()
+    })
+
+    clipboard.on('error', error => {
+      clipboard.destroy()
+      reject(error)
+    })
+
+    fakeElement.click()
+  })
+}
+
+export function copyHtml (html: string, plain: string) {
+  interface ClipboardEvent extends Event {
+    clipboardData: {
+      setData: (attribute: string, value: string) => void
+    }
+  }
+
+  function listener(event: ClipboardEvent) {
+    event.clipboardData.setData("text/html", html)
+    event.clipboardData.setData("text/plain", plain)
+    event.preventDefault()
+  }
+
+  document.addEventListener("copy", listener as EventListener)
+  document.execCommand("copy")
+  document.removeEventListener("copy", listener as EventListener)
+}

package/lib/utils/iframe-resizer.ts

@@ -0,0 +1,49 @@
+import every from 'lodash/every'
+import { Child as PymChild } from 'pym.js'
+import { injectAssets } from './assets'
+
+// Will hold the pym instance once
+var pymChild: PymChild
+// URL parameters generated by Pym
+const pymParams = ['initialWidth', 'childId', 'parentUrl', 'parentTitle']
+// Save the initial window href value in case it changes
+const initialHref = window.location.href
+
+export default class IframeResizer {
+  initializer: Promise<PymChild>
+
+  constructor () {
+    this.initializer = injectAssets('//pym.nprapps.org/pym.v1.min.js').then(() => {
+      pymChild = pymChild || new window.pym.Child({ polling: 300 })
+      return pymChild
+    })
+  }
+  sendHeight (): Promise<void> {
+    return this.initializer.then(pymChild => pymChild.sendHeight())
+  }
+  static create (): IframeResizer {
+    return new IframeResizer()
+  }
+  static template(url: string, id: string = 'icij-' + Date.now().toString(32)): string {
+    return [
+      `<script type="text/javascript" src="https://pym.nprapps.org/pym.v1.min.js"></script>`,
+      `<div id="${id}"></div>`,
+      `<script>`,
+      `const icijIframe = new pym.Parent("${id}", "${IframeResizer.deletePymParams(url)}", {})`,
+      `</script>`,
+    ].join('\n')
+  }
+  static deletePymParams(href: string = initialHref): string {
+    const url = new URL(href);
+    // Remove all unwanted param
+    for (const param of pymParams) {
+      url.searchParams.delete(param)
+    }
+    // Rebuild the URL
+    return url.href
+  }
+  static isEmbedded (href: string = initialHref): boolean {
+    const url = new URL(href)
+    return every(pymParams, param => url.searchParams.has(param))
+  }
+}

package/lib/utils/placeholder.ts

@@ -0,0 +1,66 @@
+import { BoxStyle, ContentPlaceholderStyledRow, ContentPlaceholderRow, ContentPlaceholderRowBoxes, ContentPlaceholderStyledRows, ContentPlaceholderRows } from "@/utils/placeholderTypes"
+
+export function isFlexBasis(value: string | number): boolean {
+  return Number(value).toString() === value.toString()
+}
+
+export function isWidth(value: string | number): boolean {
+  const valueAsStr = String(value)
+  const cssSuffix = ['px', '%', 'em', 'rem']
+  let checkState = false
+  cssSuffix.forEach(suffix => {
+    if (Number(valueAsStr.split(suffix)[0]) &&
+      valueAsStr.split(suffix)[1] === '' &&
+      valueAsStr.split(suffix).length === 2) {
+      checkState = true
+    }
+  })
+  return checkState
+}
+
+export function getBoxStyle(left: number, width: number, isLast: boolean, subClass: string = 'box'): BoxStyle[] {
+  const arr: BoxStyle[] = []
+
+  if (left !== 0) {
+    if (isFlexBasis(left)) {
+      arr.push({ style: `flex-grow: ${left}; flex-shrink: 0; flex-basis: 0;`, subClass })
+    } else if (isWidth(left)) {
+      arr.push({ style: `flex-grow: 0; flex-shrink: 0; flex-basis: ${left};`, subClass })
+    }
+  }
+  if (isFlexBasis(width)) {
+    arr.push({ style: `flex-grow: ${width}; flex-shrink: 0; flex-basis: 0;` })
+  } else if (isWidth(width)) {
+    arr.push({ style: `flex-grow: 0; flex-shrink: 0; flex-basis: ${width};` })
+  }
+  if (isLast) {
+    arr.push({ style: 'flex-grow: 1; flex-shrink: 0; flex-basis: 0;', subClass })
+  }
+  return arr
+}
+
+export function formatRows(rows: ContentPlaceholderRows, subClass: string = 'box'): ContentPlaceholderStyledRows {
+  const rowArr: ContentPlaceholderStyledRows = rows.map((row: ContentPlaceholderRow) => {
+    // Will contain all boxes in 
+    const rowBoxes: Array<BoxStyle> = []
+    // Create placeholder row with initial height
+    const rowObj: ContentPlaceholderStyledRow = { height: row.height, boxes: [] }
+    // Add style
+    row.boxes.forEach((box: Array<any>, index: number) => {
+      const isLast: boolean = index === row.boxes.length - 1
+      // Merge the box styles
+      rowBoxes.push(...getBoxStyle(box[0], box[1], isLast, subClass))
+    })
+    rowObj.boxes = rowBoxes
+    return rowObj
+  })
+
+  return rowArr
+}
+
+export default {
+  isFlexBasis,
+  isWidth,
+  getBoxStyle,
+  formatRows
+}

package/lib/utils/placeholderTypes.ts

@@ -0,0 +1,21 @@
+import type { StyleValue } from 'vue'
+
+export interface BoxStyle {
+  style: StyleValue,
+  subClass?: string
+}
+
+export type ContentPlaceholderRowBoxes = Array<Array<number | string>>
+
+export interface ContentPlaceholderRow {
+  height: number | string,
+  boxes: ContentPlaceholderRowBoxes
+}
+
+export interface ContentPlaceholderStyledRow {
+  height: number | string,
+  boxes: Array<BoxStyle>
+}
+
+export type ContentPlaceholderStyledRows = Array<ContentPlaceholderStyledRow>
+export type ContentPlaceholderRows = Array<ContentPlaceholderRow>

package/lib/utils/strings.ts

@@ -0,0 +1,8 @@
+export function isUrl(value: string): boolean {
+  try {
+    new URL(value)
+  } catch (_) {
+    return false
+  }
+  return true
+}

package/loaders/highlight-loader.js

@@ -0,0 +1,13 @@
+const hljs = require('highlight.js')
+const loaderUtils = require('loader-utils')
+
+module.exports = function highlightLoader(source) {
+  this && this.cacheable && this.cacheable()
+  const query = loaderUtils.parseQuery(this.query || '?')
+  const language = query.lang
+  const code = hljs.getLanguage(language) ? hljs.highlight(source, { language }) : hljs.highlightAuto(source)
+  const json = JSON.stringify(code.value)
+    .replace(/\u2028/g, '\\u2028')
+    .replace(/\u2029/g, '\\u2029');
+  return `module.exports = ${json}`;
+}

package/loaders/markdown-loader.js

@@ -0,0 +1,91 @@
+'use strict'
+
+/**
+ * @src https://github.com/vuejs/vuepress/tree/master/packages/%40vuepress/markdown-loader
+ * Module dependencies.
+ */
+
+const { EventEmitter } = require('events')
+const { getOptions } = require('loader-utils')
+const { fs, path, hash, parseFrontmatter, } = require('@vuepress/shared-utils')
+const LRU = require('lru-cache')
+const md = require('@vuepress/markdown')
+
+const cache = LRU({ max: 1000 })
+
+/**
+ * Expose markdown loader.
+ */
+
+module.exports = function (src) {
+  const isProd = process.env.NODE_ENV === 'production'
+  const options = getOptions(this)
+  const { sourceDir } = options
+  let { markdown } = options
+  // Duck-typing to ensure we received a correct markdown-it instance
+  if (!markdown || !markdown.parse) {
+    markdown = md()
+  }
+
+  // we implement a manual cache here because this loader is chained before
+  // vue-loader, and will be applied on the same file multiple times when
+  // selecting the individual blocks.
+  const file = this.resourcePath
+  const key = hash(file + src)
+  const cached = cache.get(key)
+  if (cached && (isProd || /\?vue/.test(this.resourceQuery))) {
+    return cached
+  }
+
+  const frontmatter = parseFrontmatter(src)
+  const content = frontmatter.content
+
+  // the render method has been augmented to allow plugins to
+  // register data during render
+  const { html, data: { hoistedTags, links }, dataBlockString } = markdown.render(content)
+
+  // check if relative links are valid
+  links && links.forEach(link => {
+    link = decodeURIComponent(link)
+
+    const shortname = link
+      .replace(/#.*$/, '')
+      .replace(/\.html$/, '.md')
+
+    const filename = shortname
+      .replace(/\/$/, '/README.md')
+      .replace(/^\//, sourceDir + '/')
+
+    const altname = shortname
+      .replace(/\/$/, '/index.md')
+      .replace(/^\//, sourceDir + '/')
+
+    const dir = path.dirname(this.resourcePath)
+    const file = path.resolve(dir, filename)
+    const altfile = altname !== filename ? path.resolve(dir, altname) : null
+
+    if (!fs.existsSync(file) && (!altfile || !fs.existsSync(altfile))) {
+      this.emitWarning(
+        new Error(
+          `\nFile for relative link "${link}" does not exist.\n` +
+          `(Resolved file: ${file})\n`
+        )
+      )
+    }
+  })
+
+  const res = (
+    `<template>\n` +
+      `<div>${html}</div>\n` +
+    `</template>\n` +
+    `<script>
+      export default { }
+    </script>` +
+    (hoistedTags || []).join('\n') +
+    `\n${dataBlockString}\n`
+  )
+  cache.set(key, res)
+  return res
+}
+
+module.exports.frontmatterEmitter = new EventEmitter()

package/loaders/metadata-loader.js

@@ -0,0 +1,18 @@
+const frontmatter = require('front-matter')
+const startCase = require('lodash/startCase')
+const { dirname, extname, relative } = require('path')
+
+module.exports = function metadataLoader(source) {
+  this && this.cacheable && this.cacheable();
+
+  const metadata = {
+    title: startCase(dirname(this.resourcePath).split('/').pop()),
+    resourcePath: relative('./', this.resourcePath)
+  }
+
+  if (extname(this.resourcePath) === '.md') {
+    Object.assign(metadata, frontmatter(source).attributes)
+  }
+
+  return JSON.stringify(metadata)
+}

package/loaders/sass-extract-loader.js

@@ -0,0 +1,14 @@
+const { promises: fs } = require('fs')
+const getSassVars = require('get-sass-vars')
+
+module.exports = async function sassExtractLoader() {
+  const callback = this.async()
+  try {
+    const css = await fs.readFile(this.resourcePath, 'utf-8')
+    const json = await getSassVars(css)
+    callback(null, `module.exports = ${JSON.stringify(json)}`)
+  } catch(_) {
+    callback(null, "module.exports = {}")    
+  }
+  return 
+}

package/loaders/vue-docgen-loader.js

@@ -0,0 +1,14 @@
+const vueDocs = require('vue-docgen-api')
+
+module.exports = async function vueDocgenLoader() {
+  const callback = this.async()
+  const emptyApi = { "props": {}, "slots": {}, "events": {}, "methods": {} }
+  try {
+    const api = await vueDocs.parse(this.resourcePath)
+    const json = JSON.stringify(api, null, 2)
+    callback(null, `module.exports = ${json}`)
+  } catch (_) {
+    callback(null, `module.exports = ${emptyApi}`)
+  }
+  return
+};