@peaceroad/markdown-it-figure-with-p-caption 0.19.0 → 0.20.0

package/caption-numbering/counter-series.js

@@ -0,0 +1,62 @@
+import {
+  getMarkRegStateForLanguages,
+  isCaptionLabelForMark,
+} from 'p7d-markdown-it-p-captions'
+
+const hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value, key)
+
+const validateCaptionDecision = (captionDecision) => {
+  if (!captionDecision || typeof captionDecision !== 'object' || Array.isArray(captionDecision)) {
+    throw new TypeError('captionDecision must be an object returned by p-captions.')
+  }
+  if (typeof captionDecision.mark !== 'string' || captionDecision.mark.length === 0) {
+    throw new TypeError('captionDecision.mark must be a non-empty canonical mark.')
+  }
+  if (captionDecision.mark === 'code' || captionDecision.mark === 'samp') {
+    throw new TypeError('captionDecision.mark must use the canonical pre-code or pre-samp mark.')
+  }
+}
+
+export const createFigureCaptionCounterKeyResolverFromMarkRegState = (markRegState) => {
+  const resolveCounterKey = (captionDecision) => {
+    const mark = captionDecision.mark
+    if (mark === 'img') return 'figure'
+    if (mark === 'pre-code') return 'listing'
+    if (mark === 'pre-samp') {
+      const labelText = captionDecision.labelText
+      if (isCaptionLabelForMark(labelText, 'img', markRegState)) return 'figure'
+      if (isCaptionLabelForMark(labelText, 'pre-code', markRegState)) return 'listing'
+      return 'samp'
+    }
+    return mark
+  }
+  return Object.freeze(resolveCounterKey)
+}
+
+export const createFigureCaptionCounterKeyResolver = (options) => {
+  if (options !== undefined && (
+    !options ||
+    typeof options !== 'object' ||
+    Array.isArray(options)
+  )) {
+    throw new TypeError('counter-key resolver options must be an object or undefined.')
+  }
+  const normalizedOptions = options || {}
+  const keys = Object.keys(normalizedOptions)
+  for (let index = 0; index < keys.length; index++) {
+    if (keys[index] !== 'languages') {
+      throw new TypeError(`counter-key resolver option "${keys[index]}" is not supported.`)
+    }
+  }
+  const languages = hasOwn(normalizedOptions, 'languages')
+    ? normalizedOptions.languages
+    : undefined
+  const resolveCounterKey = createFigureCaptionCounterKeyResolverFromMarkRegState(
+    getMarkRegStateForLanguages(languages),
+  )
+  const resolveValidatedCounterKey = (captionDecision) => {
+    validateCaptionDecision(captionDecision)
+    return resolveCounterKey(captionDecision)
+  }
+  return Object.freeze(resolveValidatedCounterKey)
+}

package/caption-numbering/number-codec.js

@@ -0,0 +1,101 @@
+import { markAfterNum } from 'p7d-markdown-it-p-captions'
+
+const captionNumberReg = new RegExp('^(?:' + markAfterNum + ')$')
+const numberingContexts = new WeakSet()
+
+const parseAsciiPositiveIntegerOrNull = (text) => {
+  if (typeof text !== 'string' || text.length === 0) return null
+  let value = 0
+  for (let index = 0; index < text.length; index++) {
+    const code = text.charCodeAt(index)
+    if (code < 0x30 || code > 0x39) return null
+    value = value * 10 + code - 0x30
+  }
+  return Number.isSafeInteger(value) && value > 0 ? value : null
+}
+
+const freezeNumberingContext = (context) => {
+  const frozen = Object.freeze(context)
+  numberingContexts.add(frozen)
+  return frozen
+}
+
+export const createUnscopedNumberingContext = (separator) => freezeNumberingContext({
+  scoped: false,
+  scopeKey: null,
+  sequenceKey: null,
+  displayPrefix: '',
+  separator,
+})
+
+export const createScopedNumberingContext = (
+  scopeKey,
+  sequenceKey,
+  displayPrefix,
+  separator,
+) => freezeNumberingContext({
+  scoped: true,
+  scopeKey,
+  sequenceKey,
+  displayPrefix,
+  separator,
+})
+
+export const getFigureCaptionNumberingContext = (value) => {
+  if (!value || !numberingContexts.has(value)) {
+    throw new TypeError('numberingContext must be created by the figure caption-numbering API.')
+  }
+  return value
+}
+
+export const getCaptionNumberingContext = (captionContext) => {
+  return getFigureCaptionNumberingContext(captionContext && captionContext.numbering)
+}
+
+export const parseFigureCaptionExplicitNumberUnchecked = (number, numbering) => {
+  if (!numbering.scoped) return parseAsciiPositiveIntegerOrNull(number)
+  const prefix = numbering.displayPrefix + numbering.separator
+  if (!number.startsWith(prefix)) return null
+  return parseAsciiPositiveIntegerOrNull(number.slice(prefix.length))
+}
+
+export const formatFigureCaptionGeneratedNumberUnchecked = (sequence, numbering) => {
+  return numbering.scoped
+    ? numbering.displayPrefix + numbering.separator + sequence
+    : String(sequence)
+}
+
+export const parseFigureCaptionExplicitNumber = (number, context) => {
+  if (typeof number !== 'string') {
+    throw new TypeError('number must be a string.')
+  }
+  return parseFigureCaptionExplicitNumberUnchecked(
+    number,
+    getFigureCaptionNumberingContext(context),
+  )
+}
+
+export const formatFigureCaptionGeneratedNumber = (sequence, context) => {
+  if (!Number.isSafeInteger(sequence) || sequence < 1) {
+    throw new RangeError('sequence must be a positive safe integer.')
+  }
+  return formatFigureCaptionGeneratedNumberUnchecked(
+    sequence,
+    getFigureCaptionNumberingContext(context),
+  )
+}
+
+const numberCodec = Object.freeze({
+  parseExplicit(number, context) {
+    return parseFigureCaptionExplicitNumber(number, context)
+  },
+  format(sequence, context) {
+    const number = formatFigureCaptionGeneratedNumber(sequence, context)
+    if (!captionNumberReg.test(number)) {
+      throw new RangeError('The generated figure caption number exceeds the p-captions number grammar.')
+    }
+    return number
+  },
+})
+
+export const createFigureCaptionNumberCodec = () => numberCodec

package/caption-numbering/options.js

@@ -0,0 +1,101 @@
+const policyStateByPolicy = new WeakMap()
+
+export const normalizeNumberingSeparator = (value, optionName) => {
+  if (value !== '-' && value !== '.') {
+    throw new TypeError(`${optionName} must be "-" or ".".`)
+  }
+  return value
+}
+
+const normalizeScopeSources = (value) => {
+  const source = value === undefined ? ['frontmatter', 'heading'] : value
+  if (!Array.isArray(source)) {
+    throw new TypeError('autoLabelNumberPolicy.scope.sources must be an array.')
+  }
+  const sources = []
+  for (let index = 0; index < source.length; index++) {
+    const entry = source[index]
+    if (entry !== 'frontmatter' && entry !== 'heading') {
+      throw new TypeError('autoLabelNumberPolicy.scope.sources entries must be "frontmatter" or "heading".')
+    }
+    if (sources.indexOf(entry) === -1) sources.push(entry)
+  }
+  return sources
+}
+
+const normalizeHeadingLevels = (value) => {
+  const source = value === undefined ? [1] : value
+  if (!Array.isArray(source)) {
+    throw new TypeError('autoLabelNumberPolicy.scope.headingLevels must be an array.')
+  }
+  const levels = []
+  for (let index = 0; index < source.length; index++) {
+    const level = source[index]
+    if (!Number.isInteger(level) || level < 1 || level > 6) {
+      throw new RangeError('autoLabelNumberPolicy.scope.headingLevels entries must be integers from 1 through 6.')
+    }
+    if (levels.indexOf(level) === -1) levels.push(level)
+  }
+  return levels
+}
+
+export const normalizeNumberingScopeMode = (value, optionName) => {
+  if (value !== 'auto' && value !== 'document') {
+    throw new TypeError(`${optionName} must be "auto" or "document".`)
+  }
+  return value
+}
+
+export const normalizeFigureCaptionNumberingPolicy = (value) => {
+  if (value === null) return null
+  const source = value === undefined ? {} : value
+  if (typeof source !== 'object' || Array.isArray(source)) {
+    throw new TypeError('autoLabelNumberPolicy must be an object or null.')
+  }
+  const separator = normalizeNumberingSeparator(
+    source.separator === undefined ? '.' : source.separator,
+    'autoLabelNumberPolicy.separator',
+  )
+  let scope = null
+  const requestedScope = source.scope
+  if (requestedScope !== null && requestedScope !== 'document') {
+    const scopeValue = requestedScope === undefined || requestedScope === 'auto'
+      ? {}
+      : requestedScope
+    if (typeof scopeValue !== 'object' || Array.isArray(scopeValue)) {
+      throw new TypeError('autoLabelNumberPolicy.scope must be "auto", "document", an object, or null.')
+    }
+    const sources = normalizeScopeSources(scopeValue.sources)
+    const headingLevels = normalizeHeadingLevels(scopeValue.headingLevels)
+    const repeatScope = scopeValue.repeatScope === undefined ? 'continue' : scopeValue.repeatScope
+    if (repeatScope !== 'continue' && repeatScope !== 'reset') {
+      throw new TypeError('autoLabelNumberPolicy.scope.repeatScope must be "continue" or "reset".')
+    }
+    const resolveFrontmatterTitle = scopeValue.resolveFrontmatterTitle
+    if (resolveFrontmatterTitle !== undefined && resolveFrontmatterTitle !== null && typeof resolveFrontmatterTitle !== 'function') {
+      throw new TypeError('autoLabelNumberPolicy.scope.resolveFrontmatterTitle must be a function or null.')
+    }
+    scope = Object.freeze({
+      headingLevelLookup: Object.freeze(headingLevels.reduce((lookup, level) => {
+        lookup[level] = true
+        return lookup
+      }, {})),
+      repeatScope,
+      resolveFrontmatterTitle: resolveFrontmatterTitle || null,
+      usesFrontmatter: sources.indexOf('frontmatter') !== -1,
+      usesHeading: sources.indexOf('heading') !== -1,
+    })
+  }
+  const state = Object.freeze({ separator, scope })
+  const policy = Object.freeze({})
+  policyStateByPolicy.set(policy, state)
+  return policy
+}
+
+export const getFigureCaptionNumberingPolicyState = (policy) => {
+  const state = policy && policyStateByPolicy.get(policy)
+  if (!state) {
+    throw new TypeError('numberingPolicy must be created by normalizeFigureCaptionNumberingPolicy().')
+  }
+  return state
+}