clapton 0.0.13 → 0.0.14

data/lib/clapton/javascripts/node_modules/diff-dom/src/diffDOM/index.ts

@@ -0,0 +1,121 @@
+import {
+    ConstNames,
+    ConstNamesPartial,
+    DiffDOMOptions,
+    DiffDOMOptionsPartial,
+    diffType,
+    elementNodeType,
+    textNodeType,
+} from "./types"
+import { applyDOM, undoDOM } from "./dom/index"
+import { Diff } from "./helpers"
+import { DiffFinder } from "./virtual/index"
+export { nodeToObj, stringToObj } from "./virtual/index"
+
+const DEFAULT_OPTIONS = {
+    debug: false,
+    diffcap: 10, // Limit for how many diffs are accepting when debugging. Inactive when debug is false.
+    maxDepth: false, // False or a numeral. If set to a numeral, limits the level of depth that the the diff mechanism looks for differences. If false, goes through the entire tree.
+    maxChildCount: 50, // False or a numeral. If set to a numeral, only does a simplified form of diffing of contents so that the number of diffs cannot be higher than the number of child nodes.
+    valueDiffing: true, // Whether to take into consideration the values of forms that differ from auto assigned values (when a user fills out a form).
+    // syntax: textDiff: function (node, currentValue, expectedValue, newValue)
+    textDiff(
+        node: textNodeType,
+        currentValue: string,
+        expectedValue: string,
+        newValue: string,
+    ) {
+        node.data = newValue
+        return
+    },
+    // empty functions were benchmarked as running faster than both
+    // `f && f()` and `if (f) { f(); }`
+    preVirtualDiffApply() {}, // eslint-disable-line @typescript-eslint/no-empty-function
+    postVirtualDiffApply() {}, // eslint-disable-line @typescript-eslint/no-empty-function
+    preDiffApply() {}, // eslint-disable-line @typescript-eslint/no-empty-function
+    postDiffApply() {}, // eslint-disable-line @typescript-eslint/no-empty-function
+    filterOuterDiff: null,
+    compress: false, // Whether to work with compressed diffs
+    _const: false, // object with strings for every change types to be used in diffs.
+    document:
+        typeof window !== "undefined" && window.document
+            ? window.document
+            : false,
+    components: [], // list of components used for converting from string
+}
+
+export class DiffDOM {
+    options: DiffDOMOptions
+    constructor(options: DiffDOMOptionsPartial = {}) {
+        // IE11 doesn't have Object.assign and buble doesn't translate object spreaders
+        // by default, so this is the safest way of doing it currently.
+        Object.entries(DEFAULT_OPTIONS).forEach(([key, value]) => {
+            if (!Object.prototype.hasOwnProperty.call(options, key)) {
+                options[key] = value
+            }
+        })
+
+        if (!options._const) {
+            const varNames = [
+                "addAttribute",
+                "modifyAttribute",
+                "removeAttribute",
+                "modifyTextElement",
+                "relocateGroup",
+                "removeElement",
+                "addElement",
+                "removeTextElement",
+                "addTextElement",
+                "replaceElement",
+                "modifyValue",
+                "modifyChecked",
+                "modifySelected",
+                "modifyComment",
+                "action",
+                "route",
+                "oldValue",
+                "newValue",
+                "element",
+                "group",
+                "groupLength",
+                "from",
+                "to",
+                "name",
+                "value",
+                "data",
+                "attributes",
+                "nodeName",
+                "childNodes",
+                "checked",
+                "selected",
+            ]
+            const constNames: ConstNamesPartial = {}
+            if (options.compress) {
+                varNames.forEach(
+                    (varName, index) => (constNames[varName] = index),
+                )
+            } else {
+                varNames.forEach((varName) => (constNames[varName] = varName))
+            }
+            options._const = constNames as ConstNames
+        }
+
+        this.options = options as DiffDOMOptions
+    }
+
+    apply(tree: Element, diffs: (Diff | diffType)[]) {
+        return applyDOM(tree, diffs, this.options)
+    }
+
+    undo(tree: Element, diffs: (Diff | diffType)[]) {
+        return undoDOM(tree, diffs, this.options)
+    }
+
+    diff(
+        t1Node: string | elementNodeType | Element,
+        t2Node: string | elementNodeType | Element,
+    ) {
+        const finder = new DiffFinder(t1Node, t2Node, this.options)
+        return finder.init()
+    }
+}

data/lib/clapton/javascripts/node_modules/diff-dom/src/diffDOM/types.ts

@@ -0,0 +1,154 @@
+import { Diff } from "./helpers"
+
+interface subsetType {
+    oldValue: number
+    newValue: number
+    length: number
+    delete?: true
+}
+
+interface elementNodeType {
+    nodeName: string
+    attributes?: { [key: string]: string }
+    childNodes?: nodeType[] // eslint-disable-line no-use-before-define
+    checked?: boolean
+    value?: string | number
+    selected?: boolean
+}
+
+interface textNodeType {
+    nodeName: "#text" | "#comment"
+    data: string
+    childNodes?: never
+}
+
+type nodeType = elementNodeType | textNodeType
+
+interface elementDiffNodeType extends elementNodeType {
+    childNodes?: diffNodeType[] // eslint-disable-line no-use-before-define
+    // The following are only used during diffing.
+    subsets?: subsetType[]
+    subsetsAge?: number
+    outerDone?: boolean
+    innerDone?: boolean
+    valueDone?: boolean
+}
+
+interface textDiffNodeType extends textNodeType {
+    // The following are only used during diffing.
+    outerDone?: boolean
+}
+
+type diffNodeType = elementDiffNodeType | textDiffNodeType
+
+interface Document {
+    createElement: (arg: string) => Element
+    createElementNS: (namespaceURI: string, qualifiedName: string) => Element
+    createTextNode: (arg: string) => Text
+    createComment: (arg: string) => Comment
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+interface PreDiffApplyOptions {
+    diff: Diff
+    node: nodeType
+}
+
+type PreDiffApply = (PreDiffApplyOptions) => boolean
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+interface PostDiffApplyOptions {
+    diff: Diff
+    node: nodeType
+    newNode: nodeType
+}
+
+type PostDiffApply = (PostDiffApplyOptions) => void
+
+interface ConstNames {
+    addAttribute: string | number
+    modifyAttribute: string | number
+    removeAttribute: string | number
+    modifyTextElement: string | number
+    relocateGroup: string | number
+    removeElement: string | number
+    addElement: string | number
+    removeTextElement: string | number
+    addTextElement: string | number
+    replaceElement: string | number
+    modifyValue: string | number
+    modifyChecked: string | number
+    modifySelected: string | number
+    modifyComment: string | number
+    action: string | number
+    route: string | number
+    oldValue: string | number
+    newValue: string | number
+    element: string | number
+    group: string | number
+    groupLength: string | number
+    from: string | number
+    to: string | number
+    name: string | number
+    value: string | number
+    data: string | number
+    attributes: string | number
+    nodeName: string | number
+    childNodes: string | number
+    checked: string | number
+    selected: string | number
+}
+
+interface DiffDOMOptions {
+    debug: boolean
+    diffcap: number // Limit for how many diffs are accepting when debugging. Inactive when debug is false.
+    maxDepth: number | false // False or a numeral. If set to a numeral, limits the level of depth that the the diff mechanism looks for differences. If false, goes through the entire tree.
+    maxChildCount: number // False or a numeral. If set to a numeral, only does a simplified form of diffing of contents so that the number of diffs cannot be higher than the number of child nodes.
+    valueDiffing: boolean // Whether to take into consideration the values of forms that differ from auto assigned values (when a user fills out a form).
+    caseSensitive: boolean // Whether to preserve the case of an input string. Important when including CML (XHTML, SVG, etc.)
+    // syntax: textDiff: function (node, currentValue, expectedValue, newValue)
+    textDiff: (
+        node: textNodeType | Text | Comment,
+        currentValue: string,
+        expectedValue: string,
+        newValue: string,
+    ) => void
+    preVirtualDiffApply: PreDiffApply
+    postVirtualDiffApply: PostDiffApply
+    preDiffApply: PreDiffApply
+    postDiffApply: PostDiffApply
+    filterOuterDiff: null | ((t1, t2, diffs: Diff[]) => void | Diff[])
+    compress: boolean // Whether to work with compressed diffs
+    _const: ConstNames // object with strings for every change types to be used in diffs.
+    document: Document
+    components: string[]
+}
+
+type DiffDOMOptionsPartial = Partial<DiffDOMOptions>
+
+type ConstNamesPartial = Partial<ConstNames>
+
+type diffType = {
+    [key: string | number]:
+        | string
+        | number
+        | boolean
+        | number[]
+        | { [key: string]: string | { [key: string]: string } }
+        | elementNodeType
+}
+
+export {
+    nodeType,
+    ConstNames,
+    ConstNamesPartial,
+    DiffDOMOptions,
+    DiffDOMOptionsPartial,
+    diffType,
+    diffNodeType,
+    elementDiffNodeType,
+    elementNodeType,
+    subsetType,
+    textDiffNodeType,
+    textNodeType,
+}

data/lib/clapton/javascripts/node_modules/diff-dom/src/diffDOM/virtual/apply.ts

@@ -0,0 +1,349 @@
+import { DiffDOMOptions, elementNodeType, nodeType, subsetType } from "../types"
+import { Diff } from "../helpers"
+import { cleanNode } from "./helpers"
+// ===== Apply a virtual diff =====
+
+function getFromVirtualRoute(tree: elementNodeType, route: number[]) {
+    let node = tree
+    let parentNode
+    let nodeIndex
+
+    route = route.slice()
+    while (route.length > 0) {
+        nodeIndex = route.splice(0, 1)[0]
+        parentNode = node
+        node = node.childNodes ? node.childNodes[nodeIndex] : undefined
+    }
+    return {
+        node,
+        parentNode,
+        nodeIndex,
+    }
+}
+
+function applyVirtualDiff(
+    tree: elementNodeType,
+    diff: Diff,
+    options: DiffDOMOptions, // {preVirtualDiffApply, postVirtualDiffApply, _const}
+) {
+    let node, parentNode, nodeIndex
+
+    if (
+        ![options._const.addElement, options._const.addTextElement].includes(
+            diff[options._const.action],
+        )
+    ) {
+        // For adding nodes, we calculate the route later on. It's different because it includes the position of the newly added item.
+        const routeInfo = getFromVirtualRoute(tree, diff[options._const.route])
+        node = routeInfo.node
+        parentNode = routeInfo.parentNode
+        nodeIndex = routeInfo.nodeIndex
+    }
+
+    const newSubsets: subsetType[] = []
+
+    // pre-diff hook
+    const info = {
+        diff,
+        node,
+    }
+
+    if (options.preVirtualDiffApply(info)) {
+        return true
+    }
+
+    let newNode
+    let nodeArray
+    let route
+
+    switch (diff[options._const.action]) {
+        case options._const.addAttribute:
+            if (!node.attributes) {
+                node.attributes = {}
+            }
+
+            node.attributes[diff[options._const.name]] =
+                diff[options._const.value]
+
+            if (diff[options._const.name] === "checked") {
+                node.checked = true
+            } else if (diff[options._const.name] === "selected") {
+                node.selected = true
+            } else if (
+                node.nodeName === "INPUT" &&
+                diff[options._const.name] === "value"
+            ) {
+                node.value = diff[options._const.value]
+            }
+
+            break
+        case options._const.modifyAttribute:
+            node.attributes[diff[options._const.name]] =
+                diff[options._const.newValue]
+            break
+        case options._const.removeAttribute:
+            delete node.attributes[diff[options._const.name]]
+
+            if (Object.keys(node.attributes).length === 0) {
+                delete node.attributes
+            }
+
+            if (diff[options._const.name] === "checked") {
+                node.checked = false
+            } else if (diff[options._const.name] === "selected") {
+                delete node.selected
+            } else if (
+                node.nodeName === "INPUT" &&
+                diff[options._const.name] === "value"
+            ) {
+                delete node.value
+            }
+
+            break
+        case options._const.modifyTextElement:
+            node.data = diff[options._const.newValue]
+            if (parentNode.nodeName === "TEXTAREA") {
+                parentNode.value = diff[options._const.newValue]
+            }
+            break
+        case options._const.modifyValue:
+            node.value = diff[options._const.newValue]
+            break
+        case options._const.modifyComment:
+            node.data = diff[options._const.newValue]
+            break
+        case options._const.modifyChecked:
+            node.checked = diff[options._const.newValue]
+            break
+        case options._const.modifySelected:
+            node.selected = diff[options._const.newValue]
+            break
+        case options._const.replaceElement:
+            newNode = cleanNode(diff[options._const.newValue])
+            parentNode.childNodes[nodeIndex] = newNode
+            break
+        case options._const.relocateGroup:
+            nodeArray = node.childNodes
+                .splice(
+                    diff[options._const.from],
+                    diff[options._const.groupLength],
+                )
+                .reverse()
+            nodeArray.forEach((movedNode: nodeType) =>
+                node.childNodes.splice(diff[options._const.to], 0, movedNode),
+            )
+            if (node.subsets) {
+                node.subsets.forEach((map: subsetType) => {
+                    if (
+                        diff[options._const.from] < diff[options._const.to] &&
+                        map.oldValue <= diff[options._const.to] &&
+                        map.oldValue > diff[options._const.from]
+                    ) {
+                        map.oldValue -= diff[options._const.groupLength]
+                        const splitLength =
+                            map.oldValue + map.length - diff[options._const.to]
+                        if (splitLength > 0) {
+                            // new insertion splits map.
+                            newSubsets.push({
+                                oldValue:
+                                    diff[options._const.to] +
+                                    diff[options._const.groupLength],
+                                newValue:
+                                    map.newValue + map.length - splitLength,
+                                length: splitLength,
+                            })
+                            map.length -= splitLength
+                        }
+                    } else if (
+                        diff[options._const.from] > diff[options._const.to] &&
+                        map.oldValue > diff[options._const.to] &&
+                        map.oldValue < diff[options._const.from]
+                    ) {
+                        map.oldValue += diff[options._const.groupLength]
+                        const splitLength =
+                            map.oldValue + map.length - diff[options._const.to]
+                        if (splitLength > 0) {
+                            // new insertion splits map.
+                            newSubsets.push({
+                                oldValue:
+                                    diff[options._const.to] +
+                                    diff[options._const.groupLength],
+                                newValue:
+                                    map.newValue + map.length - splitLength,
+                                length: splitLength,
+                            })
+                            map.length -= splitLength
+                        }
+                    } else if (map.oldValue === diff[options._const.from]) {
+                        map.oldValue = diff[options._const.to]
+                    }
+                })
+            }
+
+            break
+        case options._const.removeElement:
+            parentNode.childNodes.splice(nodeIndex, 1)
+            if (parentNode.subsets) {
+                parentNode.subsets.forEach((map: subsetType) => {
+                    if (map.oldValue > nodeIndex) {
+                        map.oldValue -= 1
+                    } else if (map.oldValue === nodeIndex) {
+                        map.delete = true
+                    } else if (
+                        map.oldValue < nodeIndex &&
+                        map.oldValue + map.length > nodeIndex
+                    ) {
+                        if (map.oldValue + map.length - 1 === nodeIndex) {
+                            map.length--
+                        } else {
+                            newSubsets.push({
+                                newValue:
+                                    map.newValue + nodeIndex - map.oldValue,
+                                oldValue: nodeIndex,
+                                length:
+                                    map.length - nodeIndex + map.oldValue - 1,
+                            })
+                            map.length = nodeIndex - map.oldValue
+                        }
+                    }
+                })
+            }
+            node = parentNode
+            break
+        case options._const.addElement: {
+            route = diff[options._const.route].slice()
+            const c: number = route.splice(route.length - 1, 1)[0]
+            node = getFromVirtualRoute(tree, route)?.node
+            newNode = cleanNode(diff[options._const.element])
+
+            if (!node.childNodes) {
+                node.childNodes = []
+            }
+
+            if (c >= node.childNodes.length) {
+                node.childNodes.push(newNode)
+            } else {
+                node.childNodes.splice(c, 0, newNode)
+            }
+            if (node.subsets) {
+                node.subsets.forEach((map: subsetType) => {
+                    if (map.oldValue >= c) {
+                        map.oldValue += 1
+                    } else if (
+                        map.oldValue < c &&
+                        map.oldValue + map.length > c
+                    ) {
+                        const splitLength = map.oldValue + map.length - c
+                        newSubsets.push({
+                            newValue: map.newValue + map.length - splitLength,
+                            oldValue: c + 1,
+                            length: splitLength,
+                        })
+                        map.length -= splitLength
+                    }
+                })
+            }
+            break
+        }
+        case options._const.removeTextElement:
+            parentNode.childNodes.splice(nodeIndex, 1)
+            if (parentNode.nodeName === "TEXTAREA") {
+                delete parentNode.value
+            }
+            if (parentNode.subsets) {
+                parentNode.subsets.forEach((map: subsetType) => {
+                    if (map.oldValue > nodeIndex) {
+                        map.oldValue -= 1
+                    } else if (map.oldValue === nodeIndex) {
+                        map.delete = true
+                    } else if (
+                        map.oldValue < nodeIndex &&
+                        map.oldValue + map.length > nodeIndex
+                    ) {
+                        if (map.oldValue + map.length - 1 === nodeIndex) {
+                            map.length--
+                        } else {
+                            newSubsets.push({
+                                newValue:
+                                    map.newValue + nodeIndex - map.oldValue,
+                                oldValue: nodeIndex,
+                                length:
+                                    map.length - nodeIndex + map.oldValue - 1,
+                            })
+                            map.length = nodeIndex - map.oldValue
+                        }
+                    }
+                })
+            }
+            node = parentNode
+            break
+        case options._const.addTextElement: {
+            route = diff[options._const.route].slice()
+            const c: number = route.splice(route.length - 1, 1)[0]
+            newNode = {
+                nodeName: "#text",
+                data: diff[options._const.value],
+            }
+            node = getFromVirtualRoute(tree, route).node
+            if (!node.childNodes) {
+                node.childNodes = []
+            }
+
+            if (c >= node.childNodes.length) {
+                node.childNodes.push(newNode)
+            } else {
+                node.childNodes.splice(c, 0, newNode)
+            }
+            if (node.nodeName === "TEXTAREA") {
+                node.value = diff[options._const.newValue]
+            }
+            if (node.subsets) {
+                node.subsets.forEach((map: subsetType) => {
+                    if (map.oldValue >= c) {
+                        map.oldValue += 1
+                    }
+                    if (map.oldValue < c && map.oldValue + map.length > c) {
+                        const splitLength = map.oldValue + map.length - c
+                        newSubsets.push({
+                            newValue: map.newValue + map.length - splitLength,
+                            oldValue: c + 1,
+                            length: splitLength,
+                        })
+                        map.length -= splitLength
+                    }
+                })
+            }
+            break
+        }
+        default:
+            console.log("unknown action")
+    }
+
+    if (node.subsets) {
+        node.subsets = node.subsets.filter(
+            (map: subsetType) => !map.delete && map.oldValue !== map.newValue,
+        )
+        if (newSubsets.length) {
+            node.subsets = node.subsets.concat(newSubsets)
+        }
+    }
+
+    options.postVirtualDiffApply({
+        node: info.node,
+        diff: info.diff,
+        newNode,
+    })
+
+    return
+}
+
+export function applyVirtual(
+    tree: elementNodeType,
+    diffs: Diff[],
+    options: DiffDOMOptions,
+) {
+    diffs.forEach((diff: Diff) => {
+        applyVirtualDiff(tree, diff, options)
+    })
+    return true
+}