@thegetty/quire-cli 1.0.0-pre-release.1 → 1.0.0-pre-release.2

package/src/lib/quire/versions/1.0.0-pre-release.2/_plugins/figures/figure/factory.js

@@ -1,34 +0,0 @@
-const Figure = require('./index')
-const ImageProcessor = require('../image/processor')
-const path = require('path')
-
-/**
- * Factory class to create instances of `Figure` on which process is called
- * to generate files and set computed properties used the Quire shortcodes.
- *
- * @class FigureFactory
- */
-module.exports = class FigureFactory {
-  constructor(iiifConfig) {
-    this.iiifConfig = iiifConfig
-    this.imageProcessor = new ImageProcessor(iiifConfig)
-  }
-
-  /**
-   * Creates a `Figure` instance and calls its `processFiles` method
-   * to create the IIIF info, manifest, and generate image tiles.
-   *
-   * @param {Object} data  A figure entry from `figures.yaml`
-   * 
-   * @return {Object}
-   * @property {Figure} figure  A new Figure instance
-   * @property {Array} errors  `processFiles` errors
-   */
-  async create(data) {
-    const processImage =
-      this.imageProcessor.processImage.bind(this.imageProcessor)
-    const figure = new Figure(this.iiifConfig, processImage, data)
-    const { errors } = await figure.processFiles()
-    return { figure, errors }
-  }
-}

package/src/lib/quire/versions/1.0.0-pre-release.2/_plugins/figures/figure/index.js

@@ -1,238 +0,0 @@
-const chalkFactory = require('~lib/chalk')
-const Annotation = require('../annotation')
-const AnnotationFactory = require('../annotation/factory')
-const Manifest = require('../iiif/manifest')
-const path = require('path')
-const sharp = require('sharp')
-const { isCanvas, isImageService } = require('../helpers')
-
-const logger = chalkFactory('Figures:Figure', 'DEBUG')
-
-/**
- * @param {Object} iiifConfig
- * @param {Function} processImage  Function to generate IIIF assets
- * @param {Object} data  Figure data from and entry in `figures.yaml`
- * 
- * @typedef {Object} Figure
- * @property {Array<AnnotationSet>} annotations
- * @property {String} canvasId ID of IIIF canvas
- * @property {Boolean} isCanvas True if figure contains a canvas resource
- * @property {Boolean} isExternalResource True if figure references an externally hosted resource
- * @property {Boolean} isImageService True if figure contains an image service resource
- * @property {String} manifestId ID of IIIF manifest
- * @property {String} printImage Optional path to an alternate image to use in print
- */
-module.exports = class Figure {
-  constructor(iiifConfig, imageProcessor, data) {
-    const { baseURI, dirs, manifestFileName } = iiifConfig
-    const outputDir = path.join(dirs.outputPath, data.id)
-    /**
-     * URI of the IIIF CanvasPanel element; a fully qualified URL.
-     * @type  {URL|null}
-     */
-    const canvasId = isCanvas(data)
-      ? data.canvasId || [baseURI, outputDir, 'canvas'].join('/')
-      : null
-    /**
-     * URI of the IIIF manifest file; a fully qualified URL.
-     * @type  {URL|null}
-     */
-    const manifestId = isCanvas(data)
-      ? data.manifestId || [baseURI, outputDir, manifestFileName].join('/')
-      : null
-
-    const defaults = {
-      mediaType: 'image'
-    }
-
-    const { 
-      id,
-      label,
-      media_id: mediaId,
-      media_type: mediaType,
-      src,
-      zoom
-    } = data
-
-    this.annotationFactory = new AnnotationFactory(this)
-    this.canvasId = canvasId
-    this.data = data
-    this.id = id
-    this.iiifConfig = iiifConfig
-    this.isCanvas = isCanvas(data)
-    this.isImageService = isImageService(data)
-    this.label = label
-    this.manifestId = manifestId
-    this.mediaType = mediaType || defaults.mediaType
-    this.mediaId = mediaId
-    this.outputDir = outputDir
-    this.processImage = imageProcessor
-    this.src = src
-    this.zoom = zoom
-  }
-
-  /**
-   * Figure image annotations
-   * @type  {Array<Annotations>}
-   */
-  get annotations() {
-    return this.annotationFactory.create()
-  }
-
-  /**
-   * When the figure is a canvas, represent the image
-   * in `figure.src` as an annotation for use in IIIF manifests
-   * @return {Annotation|null}
-   */
-  get baseImageAnnotation() {
-    const { src, label } = this.data
-    return src && this.isCanvas
-      ? new Annotation(this, { label, src })
-      : null
-  }
-
-  /**
-   * Path to the image file that represents the canvas
-   * Used to define canvas properties `width` and `height`
-   */
-  get canvasImagePath() {
-    if (!this.isCanvas) return
-    const firstChoiceSrc = () => {
-      if (!this.annotations) return
-      const firstChoice = this.annotations
-        .flatMap(({ items }) => items)
-        .find(({ target }) => !target)
-      if (!firstChoice) return
-      return firstChoice.src
-    }
-    const imagePath = this.src || firstChoiceSrc()
-    if (!imagePath) {
-      this.errors.push(`Invalid figure ID "${this.id}". Figures with annotations must have "choice" annotations or a "src" property.`)
-      return
-    }
-    const { imagesDir, inputRoot } = this.iiifConfig.dirs
-    return path.join(inputRoot, imagesDir, imagePath)
-  }
-
-  /**
-   * Test if the `src` is an external resource
-   * @return {Boolean}
-   */
-  get isExternalResource() {
-    return (this.src && this.src.startsWith('http')) || this.data.manifestId
-  }
-
-  /**
-   * Path to a print representation of the figure for EPUB & PDF outputs
-   * @type {String}
-   */
-  get printImage() {
-    if (!this.isExternalResource && this.src && !this.data.printImage) {
-      const { ext, name } = path.parse(this.src)
-      return path.join('/', this.outputDir, name, `print-image${ext}`)
-    }
-    return this.data.printImage
-  }
-
-  /**
-   * The figure region to display on load
-   * @return {String} format "x,y,width,height" Defaults to full dimensions
-   */
-  get region() {
-    if (this.isExternal || this.mediaType !== 'image') return
-    return this.data.region || `0,0,${this.canvasWidth},${this.canvasHeight}`
-  }
-
-  /**
-   * Return only the data properties consumed by quire shortcodes
-   * @return {Object} figure
-   */
-  adapter() {
-    return {
-      ...this.data,
-      annotations: this.annotations,
-      canvasId: this.canvasId,
-      id: this.id,
-      isCanvas: this.isCanvas,
-      isImageService: this.isImageService,
-      label: this.label,
-      manifestId: this.manifestId,
-      mediaId: this.mediaId,
-      mediaType: this.mediaType,
-      printImage: this.printImage,
-      region: this.region,
-      src: this.src
-    }
-  }
-
-  /**
-   * Get the width and height of the canvas
-   */
-  async calcCanvasDimensions() {
-    if (!this.canvasImagePath) return
-    const { height, width } = await sharp(this.canvasImagePath).metadata()
-    this.canvasHeight = height
-    this.canvasWidth = width
-  }
-
-  /**
-   * Call file process methods and return errors
-   * @todo refactor process and create methods to return a response
-   * to encapsulate collection of errors into this method.
-   *
-   * @return {Object}
-   * @property {Array} errors
-   */
-  async processFiles() {
-    this.errors = []
-
-    if (this.isExternalResource) return {}
-
-    await this.calcCanvasDimensions()
-    await this.processAnnotationImages()
-    await this.processFigureImage()
-    await this.createManifest()
-
-    return { errors: this.errors }
-  }
-
-  /**
-   * Process annotation images
-   */
-  async processAnnotationImages() {
-    if (!this.annotations) return
-    const annotationItems = this.annotations.flatMap(({ items }) => items)
-    const results = await Promise.all(annotationItems.map((item) => {
-      logger.debug(`processing annotation image ${item.src}`)
-      return item.src && this.processImage(item.src, this.outputDir, {
-        tile: item.isImageService
-      })
-    }))
-    const errors = results.flatMap(({ errors }) => errors || [])
-    if (errors.length) this.errors = this.errors.concat(errors)
-  }
-
-  /**
-   * Process `figure.src`
-   */
-  async processFigureImage() {
-    if (!this.isCanvas || !this.src) return
-    const { transformations } = this.iiifConfig
-    const { errors } = await this.processImage(this.src, this.outputDir, {
-      tile: true,
-      transformations
-    })
-    if (errors) this.errors = this.errors.concat(errors)
-  }
-
-  /**
-   * Create the IIIF `manifest.json` for <canvas-panel> components,
-   * collect errors from calling toJSON and the file system writer.
-   */
-  async createManifest() {
-    if (!this.isCanvas) return
-    const manifest = new Manifest(this)
-    const { errors } = await manifest.write()
-    if (errors) this.errors = this.errors.concat(errors)
-  }
-}

package/src/lib/quire/versions/1.0.0-pre-release.2/_plugins/figures/helpers/index.js

@@ -1,4 +0,0 @@
-module.exports = {
-  isCanvas: require('./is-canvas'),
-  isImageService: require('./is-image-service')
-}

package/src/lib/quire/versions/1.0.0-pre-release.2/_plugins/figures/helpers/is-canvas.js

@@ -1,24 +0,0 @@
-const path = require('path')
-
-/**
- * Figure `isCanvas` helper
- * A figure is a canvas if it has a src and has zoom=true, has annotations,
- * or links to an external IIIF manifest
- * 
- * @param  {Object} figure Figure data
- * @return {Boolean}       True if figure contains a canvas
- */
-module.exports = (figure) => {
-  const { 
-    annotations,
-    canvasId,
-    iiifContent,
-    manifestId,
-    src,
-    zoom
-  } = figure
-  return (!!canvasId && !!manifestId)
-    || !!iiifContent
-    || !!annotations
-    || (!!src && !!zoom)
-}

package/src/lib/quire/versions/1.0.0-pre-release.2/_plugins/figures/helpers/is-image-service.js

@@ -1,12 +0,0 @@
-const path = require('path')
-
-/**
- * Test if a figure uses an image-service
- *
- * @param  {Object} figure
- * @return {Boolean}
- */
-module.exports = function(figure) {
-  const { src='' } = figure
-  return path.parse(src) === 'info.json'
-}

package/src/lib/quire/versions/1.0.0-pre-release.2/_plugins/figures/iiif/config.js

@@ -1,118 +0,0 @@
-const chalkFactory = require('~lib/chalk')
-const path = require('path')
-
-const logger = chalkFactory('Figures:IIIF:Config', 'DEBUG')
-
-
-module.exports = (eleventyConfig) => {
-  const { url } = eleventyConfig.globalData.publication
-  const { port } = eleventyConfig.serverOptions
-
-  const projectRoot = path.resolve(__dirname, '../../../')
-
-  logger.debug(`projectRoot: ${projectRoot}`)
-
-  const resolveInputPath = () => {
-    const resolvedPath = path.resolve(projectRoot, eleventyConfig.dir.input)
-    logger.debug(`inputPath: ${resolvedPath}`)
-    return resolvedPath
-  }
-
-  const resolveOutputPath = () => {
-    const { viteOptions } = eleventyConfig.plugins.find(
-      ({ options }) => !!options && !!options.viteOptions
-    ).options
-
-    const resolvedPath = viteOptions && viteOptions.publicDir
-      ? path.resolve(projectRoot, viteOptions.publicDir)
-      : path.resolve(projectRoot, eleventyConfig.dir.output)
-
-    logger.debug(`ouputPath: ${resolvedPath}`)
-    return resolvedPath
-  }
-
-  return {
-    baseURI: process.env.ELEVENTY_ENV === 'production'
-      ? url
-      : `http://localhost:${port}`,
-    dirs: {
-      /**
-       * Image file directory relative to `inputRoot`
-       */
-      imagesDir: path.join('_assets', 'images'),
-      /**
-       * Root directory for input images
-       */
-      inputRoot: resolveInputPath(),
-      /**
-       * Output directory
-       * @type {String}
-       */
-      outputPath: 'iiif',
-      outputRoot: resolveOutputPath()
-    },
-    /**
-     * Input/output of processable image formats
-     * @type {Array<Object>}
-     */
-    formats: [
-      {
-        input: ['.png', '.svg'],
-        /**
-         * Change to '.png' when canvas-panel preferredFormats issue is resolved
-         * @link https://github.com/digirati-co-uk/iiif-canvas-panel/issues/193
-         */
-        output: '.jpg'
-      },
-      {
-        input: ['.jp2', '.jpg', '.jpeg', '.tif', '.tiff'],
-        output: '.jpg'
-      }
-    ],
-    /**
-     * Locale of the generated manifest
-     * @type {String}
-     */
-    locale: 'en',
-    /**
-     * File name for the generated manifest
-     * @type {String}
-     */
-    manifestFileName: 'manifest.json',
-    /**
-     * Directory name appended to the output path for tiles and `info.json`
-     * @type {String}
-     */
-    tilesDirName: 'tiles',
-    /**
-     * Size in pixels of the smallest image tile after slicing
-     * @type {Number}
-     */
-    tileSize: 256,
-    /**
-     * All transformations are applied to each image and output a separate file.
-     *
-     * @type {Array<Object>}
-     * @property {String} name  Output file name
-     * @property {Object} resize  Options passed to the `sharp.resize()` method
-     * @see {@link https://sharp.pixelplumbing.com/api-resize}
-     */
-    transformations: [
-      {
-        name: 'thumbnail',
-        resize: {
-          width: 50
-        }
-      },
-      /**
-       * Transformation applied to IIIF resources for use in PDF and EPUB
-       */
-      {
-        name: 'print-image',
-        resize: {
-          width: 800
-        }
-      }
-    ]
-  }
-}

package/src/lib/quire/versions/1.0.0-pre-release.2/_plugins/figures/iiif/manifest/README.md

@@ -1,39 +0,0 @@
-# IIIF Manifests
-The `Manifest` module accepts a `Figure` instance and provides `toJSON()` and `write()` methods for generating and writing a IIIF manifest.
-
-## Features
-### Annotations
-An `annotation` adds additional information (for example an image) to a canvas.
-
-_figures.yaml_
-```yaml
-- id: "example-with-annotation"
-  label: "Dog"
-  src: figures/dog.jpg
-  annotations:
-    input: checkbox
-    items:
-      - src: figures/hat.jpg
-        label: "Hat"
-```
-
-### Choices
-`Choices` are a type of annotation that represent alternate views of the same image, for example an x-ray and a photograph of a painting. All `choices` should have the same image dimensions and must not have a `target` property. Choices will be listed in the order they appear in the `YAML`, the first item will be selected by default when the page loads.
-
-#### Usage
-_example-template.md_
-```liquid
-{% figure "example-with-choices" %}
-```
-
-_figures.yaml_
-```yaml
-- id: "example-with-choices"
-  label: "This is a label"
-  annotations:
-    items:
-      - src: figures/x-ray.jpg
-        label: "Choice #1"
-      - src: figures/photo.jpg
-        label: "Choice #2"
-```

package/src/lib/quire/versions/1.0.0-pre-release.2/_plugins/figures/iiif/manifest/index.js

@@ -1,139 +0,0 @@
-const chalkFactory = require('~lib/chalk')
-const fs = require('fs-extra')
-const path = require('path')
-const titleCase = require('~plugins/filters/titleCase')
-const Writer = require('./writer')
-const { globalVault } = require('@iiif/vault')
-const { IIIFBuilder } = require('iiif-builder')
-
-const logger = chalkFactory('Figures:IIIF:Manifest', 'DEBUG')
-
-const vault = globalVault()
-const builder = new IIIFBuilder(vault)
-
-/**
- * Create a IIIF manifest from a Figure instance
- */
-module.exports = class Manifest {
-  constructor(figure) {
-    const { iiifConfig } = figure
-    const { locale } = iiifConfig
-    this.figure = figure
-    this.locale = locale
-    this.writer = new Writer(iiifConfig)
-  }
-
-  get annotations() {
-    const annotations = []
-    /**
-     * Add the "base" image as a canvas annotation
-     */
-    if (this.figure.baseImageAnnotation) {
-      annotations.push(this.createAnnotation(this.figure.baseImageAnnotation))
-    }
-    if (this.figure.annotations) {
-      annotations.push(...this.figure.annotations
-        .flatMap(({ items }) => items)
-        .filter(({ type }) => type === 'annotation')
-        .map((item) => this.createAnnotation(item)))
-    }
-    return annotations
-  }
-
-  get choices() {
-    if (!this.figure.annotations) return
-    const choices = this.figure.annotations
-      .flatMap(({ items }) => items)
-      .filter(({ type }) => type === 'choice')
-
-    if (!choices.length) return
-
-    const items = choices.map((item) => {
-      if (!item.src) {
-        logger.error(`Invalid annotation on figure ID "${this.figure.id}". Annotations must have a "src" or "text" property`)
-      }
-      return this.createAnnotationBody(item)
-    })
-
-    return this.createAnnotation({
-      body: {
-        items,
-        type: 'Choice',
-      },
-      id: 'choices',
-      motivation: 'painting',
-    })
-  }
-
-  createAnnotation(data) {
-    const { body, id, motivation, target } = data
-    return {
-      body: body || this.createAnnotationBody(data),
-      id: [this.figure.canvasId, id].join('/'),
-      motivation,
-      target: target ? `${this.figure.canvasId}#xywh=${target}` : this.figure.canvasId,
-      type: 'Annotation'
-    }
-  }
-
-  /**
-   * @todo handle text annotations
-   * @todo handle annotations with target region
-   */
-  createAnnotationBody({ format, info, label, src, uri }) {
-    const { ext } = path.parse(src)
-    return {
-      format,
-      height: this.figure.canvasHeight,
-      id: uri,
-      label: { en: [label] },
-      type: 'Image',
-      service: info && [
-        {
-          '@context': 'http://iiif.io/api/image/2/context.json',
-          '@id': info,
-          profile: 'level0',
-          protocol: 'http://iiif.io/api/image'
-        }
-      ],
-      width: this.figure.canvasWidth
-    }
-  }
-
-  /**
-   * Uses `builder` to create the JSON representation of the manifest
-   * @return {JSON}
-   */
-  async toJSON() {
-    const manifest = builder.createManifest(this.figure.manifestId, (manifest) => {
-      manifest.addLabel(this.figure.label, this.locale)
-      manifest.createCanvas(this.figure.canvasId, (canvas) => {
-        canvas.height = this.figure.canvasHeight
-        canvas.width = this.figure.canvasWidth
-        if (this.annotations) {
-          this.annotations.forEach((item) => {
-            canvas.createAnnotation(item.id, item)
-          })
-        }
-        if (this.choices) {
-          canvas.createAnnotation(this.choices.id, this.choices)
-        }
-      })
-    })
-    try {
-      return builder.toPresentation3(manifest)
-    } catch(error) {
-      throw new Error(`Failed to generate manifest: ${error}`)
-    }
-  }
-
-  async write() {
-    try {
-      const json = await this.toJSON()
-      logger.info(`Generated manifest for figure "${this.figure.id}"`)
-      return await this.writer.write(json)
-    } catch(error) {
-      return { errors: [error] }
-    }
-  }
-}

package/src/lib/quire/versions/1.0.0-pre-release.2/_plugins/figures/iiif/manifest/writer.js

@@ -1,27 +0,0 @@
-const fs = require('fs-extra')
-const path = require('path')
-
-module.exports = class ManifestWriter {
-  constructor(iiifConfig) {
-    this.baseURI = iiifConfig.baseURI
-    this.outputRoot = iiifConfig.dirs.outputRoot
-  }
-
-  /**
-   * Write an IIIF manifest to the file system
-   *
-   * @param  {Object} manifest  IIIF manifest
-   */
-  write(manifest) {
-    if (!manifest) return { errors: ['Error writing manifest. Manifest is undefined.'] }
-    const uri = new URL(manifest.id)
-    const outputPath = path.join(this.outputRoot, uri.pathname)
-    try {
-      fs.ensureDirSync(path.parse(outputPath).dir)
-      fs.writeJsonSync(outputPath, manifest)
-      return { messages: [`Generated manifest ${outputPath}`] }
-    } catch(error) {
-      return { errors: [`Failed to write manifest. ${error}`] }
-    }
-  }
-}