clapton 0.0.13 → 0.0.14

data/lib/clapton/javascripts/node_modules/diff-dom/dist/dts/diffDOM/virtual/helpers.d.ts

@@ -0,0 +1,40 @@
+import { diffNodeType, elementDiffNodeType, elementNodeType, subsetType, textNodeType } from "../types";
+import { Diff } from "../helpers";
+export declare const uniqueInBoth: (l1: diffNodeType[], l2: diffNodeType[]) => {};
+export declare const removeDone: (tree: elementDiffNodeType) => any;
+export declare const cleanNode: (diffNode: diffNodeType) => elementNodeType | textNodeType;
+export declare const isEqual: (e1: diffNodeType, e2: diffNodeType) => boolean;
+export declare const roughlyEqual: (e1: diffNodeType, e2: diffNodeType, uniqueDescriptors: {
+    [key: string]: boolean;
+}, sameSiblings: boolean, preventRecursion?: boolean) => any;
+/**
+ * Generate arrays that indicate which node belongs to which subset,
+ * or whether it's actually an orphan node, existing in only one
+ * of the two trees, rather than somewhere in both.
+ *
+ * So if t1 = <img><canvas><br>, t2 = <canvas><br><img>.
+ * The longest subset is "<canvas><br>" (length 2), so it will group 0.
+ * The second longest is "<img>" (length 1), so it will be group 1.
+ * gaps1 will therefore be [1,0,0] and gaps2 [0,0,1].
+ *
+ * If an element is not part of any group, it will stay being 'true', which
+ * is the initial value. For example:
+ * t1 = <img><p></p><br><canvas>, t2 = <b></b><br><canvas><img>
+ *
+ * The "<p></p>" and "<b></b>" do only show up in one of the two and will
+ * therefore be marked by "true". The remaining parts are parts of the
+ * groups 0 and 1:
+ * gaps1 = [1, true, 0, 0], gaps2 = [true, 0, 0, 1]
+ *
+ */
+export declare const getGapInformation: (t1: elementDiffNodeType, t2: elementDiffNodeType, stable: subsetType[]) => {
+    gaps1: (number | true)[];
+    gaps2: (number | true)[];
+};
+export declare const markSubTrees: (oldTree: elementDiffNodeType, newTree: elementDiffNodeType) => any[];
+export declare class DiffTracker {
+    list: Diff[];
+    constructor();
+    add(diffs: Diff[]): void;
+    forEach(fn: (Diff: any) => void): void;
+}

data/lib/clapton/javascripts/node_modules/diff-dom/dist/dts/diffDOM/virtual/index.d.ts

@@ -0,0 +1,3 @@
+export { DiffFinder } from "./diff";
+export { nodeToObj } from "./fromDOM";
+export { stringToObj } from "./fromString";

data/lib/clapton/javascripts/node_modules/diff-dom/dist/dts/index.d.ts

@@ -0,0 +1,2 @@
+export { DiffDOM, nodeToObj, stringToObj } from "./diffDOM/index";
+export { TraceLogger } from "./TraceLogger";

data/lib/clapton/javascripts/node_modules/diff-dom/dist/index.d.ts

@@ -0,0 +1,136 @@
+declare class Diff {
+    constructor(options?: {});
+    toString(): string;
+    setValue(aKey: string | number, aValue: string | number | boolean | number[] | {
+        [key: string]: string | {
+            [key: string]: string;
+        };
+    } | elementNodeType): this;
+}
+
+interface elementNodeType {
+    nodeName: string;
+    attributes?: {
+        [key: string]: string;
+    };
+    childNodes?: nodeType[];
+    checked?: boolean;
+    value?: string | number;
+    selected?: boolean;
+}
+interface textNodeType {
+    nodeName: "#text" | "#comment";
+    data: string;
+    childNodes?: never;
+}
+type nodeType = elementNodeType | textNodeType;
+interface Document {
+    createElement: (arg: string) => Element;
+    createElementNS: (namespaceURI: string, qualifiedName: string) => Element;
+    createTextNode: (arg: string) => Text;
+    createComment: (arg: string) => Comment;
+}
+type PreDiffApply = (PreDiffApplyOptions: any) => boolean;
+type PostDiffApply = (PostDiffApplyOptions: any) => 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;
+    maxDepth: number | false;
+    maxChildCount: number;
+    valueDiffing: boolean;
+    caseSensitive: boolean;
+    textDiff: (node: textNodeType | Text | Comment, currentValue: string, expectedValue: string, newValue: string) => void;
+    preVirtualDiffApply: PreDiffApply;
+    postVirtualDiffApply: PostDiffApply;
+    preDiffApply: PreDiffApply;
+    postDiffApply: PostDiffApply;
+    filterOuterDiff: null | ((t1: any, t2: any, diffs: Diff[]) => void | Diff[]);
+    compress: boolean;
+    _const: ConstNames;
+    document: Document;
+    components: string[];
+}
+type DiffDOMOptionsPartial = Partial<DiffDOMOptions>;
+type diffType = {
+    [key: string | number]: string | number | boolean | number[] | {
+        [key: string]: string | {
+            [key: string]: string;
+        };
+    } | elementNodeType;
+};
+
+declare function nodeToObj(aNode: Element, options?: DiffDOMOptionsPartial): elementNodeType;
+
+declare const stringToObj: (html: string, options?: DiffDOMOptionsPartial) => nodeType;
+
+declare class DiffDOM {
+    options: DiffDOMOptions;
+    constructor(options?: DiffDOMOptionsPartial);
+    apply(tree: Element, diffs: (Diff | diffType)[]): boolean;
+    undo(tree: Element, diffs: (Diff | diffType)[]): void;
+    diff(t1Node: string | elementNodeType | Element, t2Node: string | elementNodeType | Element): Diff[];
+}
+
+/**
+ * Use TraceLogger to figure out function calls inside
+ * JS objects by wrapping an object with a TraceLogger
+ * instance.
+ *
+ * Pretty-prints the call trace (using unicode box code)
+ * when tracelogger.toString() is called.
+ */
+/**
+ * Wrap an object by calling new TraceLogger(obj)
+ *
+ * If you're familiar with Python decorators, this
+ * does roughly the same thing, adding pre/post
+ * call hook logging calls so that you can see
+ * what's going on.
+ */
+declare class TraceLogger {
+    messages: string[];
+    pad: string;
+    padding: string;
+    tick: number;
+    constructor(obj?: {});
+    fin(fn: string, args: string | HTMLElement | number | boolean | false | (string | HTMLElement | number | boolean | false)[]): void;
+    fout(fn: string, result: string | HTMLElement | number | boolean | false | (string | HTMLElement | number | boolean | false)[]): void;
+    format(s: string, tick: number): string;
+    log(...args: any[]): void;
+    toString(): string;
+}
+
+export { DiffDOM, TraceLogger, nodeToObj, stringToObj };