@khanacademy/perseus-linter 0.2.5 → 0.3.1

package/dist/rules/math-nested.js.flow

@@ -0,0 +1,9 @@
+/**
+ * Flowtype definitions for data
+ * Generated by Flowgen from a Typescript Definition
+ * Flowgen v1.21.0
+ * @flow
+ */
+import Rule from "../rule";
+declare var _default: Rule;
+declare export default typeof _default;

package/dist/rules/math-starts-with-space.d.ts

@@ -0,0 +1,3 @@
+import Rule from "../rule";
+declare const _default: Rule;
+export default _default;

package/dist/rules/math-starts-with-space.js.flow

@@ -0,0 +1,9 @@
+/**
+ * Flowtype definitions for data
+ * Generated by Flowgen from a Typescript Definition
+ * Flowgen v1.21.0
+ * @flow
+ */
+import Rule from "../rule";
+declare var _default: Rule;
+declare export default typeof _default;

package/dist/rules/math-text-empty.d.ts

@@ -0,0 +1,3 @@
+import Rule from "../rule";
+declare const _default: Rule;
+export default _default;

package/dist/rules/math-text-empty.js.flow

@@ -0,0 +1,9 @@
+/**
+ * Flowtype definitions for data
+ * Generated by Flowgen from a Typescript Definition
+ * Flowgen v1.21.0
+ * @flow
+ */
+import Rule from "../rule";
+declare var _default: Rule;
+declare export default typeof _default;

package/dist/rules/math-without-dollars.d.ts

@@ -0,0 +1,3 @@
+import Rule from "../rule";
+declare const _default: Rule;
+export default _default;

package/dist/rules/math-without-dollars.js.flow

@@ -0,0 +1,9 @@
+/**
+ * Flowtype definitions for data
+ * Generated by Flowgen from a Typescript Definition
+ * Flowgen v1.21.0
+ * @flow
+ */
+import Rule from "../rule";
+declare var _default: Rule;
+declare export default typeof _default;

package/dist/rules/nested-lists.d.ts

@@ -0,0 +1,3 @@
+import Rule from "../rule";
+declare const _default: Rule;
+export default _default;

package/dist/rules/nested-lists.js.flow

@@ -0,0 +1,9 @@
+/**
+ * Flowtype definitions for data
+ * Generated by Flowgen from a Typescript Definition
+ * Flowgen v1.21.0
+ * @flow
+ */
+import Rule from "../rule";
+declare var _default: Rule;
+declare export default typeof _default;

package/dist/rules/profanity.d.ts

@@ -0,0 +1,3 @@
+import Rule from "../rule";
+declare const _default: Rule;
+export default _default;

package/dist/rules/profanity.js.flow

@@ -0,0 +1,9 @@
+/**
+ * Flowtype definitions for data
+ * Generated by Flowgen from a Typescript Definition
+ * Flowgen v1.21.0
+ * @flow
+ */
+import Rule from "../rule";
+declare var _default: Rule;
+declare export default typeof _default;

package/dist/rules/table-missing-cells.d.ts

@@ -0,0 +1,3 @@
+import Rule from "../rule";
+declare const _default: Rule;
+export default _default;

package/dist/rules/table-missing-cells.js.flow

@@ -0,0 +1,9 @@
+/**
+ * Flowtype definitions for data
+ * Generated by Flowgen from a Typescript Definition
+ * Flowgen v1.21.0
+ * @flow
+ */
+import Rule from "../rule";
+declare var _default: Rule;
+declare export default typeof _default;

package/dist/rules/unbalanced-code-delimiters.d.ts

@@ -0,0 +1,3 @@
+import Rule from "../rule";
+declare const _default: Rule;
+export default _default;

package/dist/rules/unbalanced-code-delimiters.js.flow

@@ -0,0 +1,9 @@
+/**
+ * Flowtype definitions for data
+ * Generated by Flowgen from a Typescript Definition
+ * Flowgen v1.21.0
+ * @flow
+ */
+import Rule from "../rule";
+declare var _default: Rule;
+declare export default typeof _default;

package/dist/rules/unescaped-dollar.d.ts

@@ -0,0 +1,3 @@
+import Rule from "../rule";
+declare const _default: Rule;
+export default _default;

package/dist/rules/unescaped-dollar.js.flow

@@ -0,0 +1,9 @@
+/**
+ * Flowtype definitions for data
+ * Generated by Flowgen from a Typescript Definition
+ * Flowgen v1.21.0
+ * @flow
+ */
+import Rule from "../rule";
+declare var _default: Rule;
+declare export default typeof _default;

package/dist/rules/widget-in-table.d.ts

@@ -0,0 +1,3 @@
+import Rule from "../rule";
+declare const _default: Rule;
+export default _default;

package/dist/rules/widget-in-table.js.flow

@@ -0,0 +1,9 @@
+/**
+ * Flowtype definitions for data
+ * Generated by Flowgen from a Typescript Definition
+ * Flowgen v1.21.0
+ * @flow
+ */
+import Rule from "../rule";
+declare var _default: Rule;
+declare export default typeof _default;

package/dist/selector.d.ts

@@ -0,0 +1,108 @@
+/**
+ * The Selector class implements a CSS-like system for matching nodes in a
+ * parse tree based on the structure of the tree. Create a Selector object by
+ * calling the static Selector.parse() method on a string that describes the
+ * tree structure you want to match. For example, if you want to find text
+ * nodes that are direct children of paragraph nodes that immediately follow
+ * heading nodes, you could create an appropriate selector like this:
+ *
+ *   selector = Selector.parse("heading + paragraph > text");
+ *
+ * Recall from the TreeTransformer class, that we consider any object with a
+ * string-valued `type` property to be a tree node. The words "heading",
+ * "paragraph" and "text" in the selector string above specify node types and
+ * will match nodes in a parse tree that have `type` properties with those
+ * values.
+ *
+ * Selectors are designed for use during tree traversals done with the
+ * TreeTransformer traverse() method. To test whether the node currently being
+ * traversed matches a selector, simply pass the TraversalState object to the
+ * match() method of the Selector object. If the node does not match the
+ * selector, match() returns null. If it does match, then match() returns an
+ * array of nodes that match the selector. In the example above the first
+ * element of the array would be the node the heading node, the second would
+ * be the paragraph node that follows it, and the third would be the text node
+ * that is a child of the paragraph.  The last element of a returned array of
+ * nodes is always equal to the current node of the tree traversal.
+ *
+ * Code that uses a selector might look like this:
+ *
+ *   matchingNodes = selector.match(state);
+ *   if (matchingNodes) {
+ *       let heading = matchingNodes[0];
+ *       let text = matchingNodes[2];
+ *       // do something with those nodes
+ *   }
+ *
+ * The Selector.parse() method recognizes a grammar that is similar to CSS
+ * selectors:
+ *
+ * selector := treeSelector (, treeSelector)*
+ *
+ *    A selector is one or more comma-separated treeSelectors. A node matches
+ *    the selector if it matches any of the treeSelectors.
+ *
+ * treeSelector := (treeSelector combinator)? nodeSelector
+ *
+ *    A treeSelector is a nodeSelector optionally preceeded by a combinator
+ *    and another tree selector. The tree selector matches if the current node
+ *    matches the node selector and a sibling or ancestor (depending on the
+ *    combinator) of the current node matches the optional treeSelector.
+ *
+ * combinator := ' ' | '>' | '+' | '~'   // standard CSS3 combinators
+ *
+ *    A combinator is a space or punctuation character that specifies the
+ *    relationship between two nodeSelectors. A space between two
+ *    nodeSelectors means that the first selector much match an ancestor of
+ *    the node that matches the second selector. A '>' character means that
+ *    the first selector must match the parent of the node matched by the
+ *    second. The '~' combinator means that the first selector must match a
+ *    previous sibling of the node matched by the second. And the '+' selector
+ *    means that first selector must match the immediate previous sibling of
+ *    the node that matched the second.
+ *
+ * nodeSelector := <IDENTIFIER> | '*'
+ *
+ *    A nodeSelector is simply an identifier (a letter followed by any number
+ *    of letters, digits, hypens, and underscores) or the wildcard asterisk
+ *    character. A wildcard node selector matches any node. An identifier
+ *    selector matches any node that has a `type` property whose value matches
+ *    the identifier.
+ *
+ * If you call Selector.parse() on a string that does not match this grammar,
+ * it will throw an exception
+ *
+ * TODO(davidflanagan): it might be useful to allow more sophsticated node
+ * selector matching with attribute matches and pseudo-classes, like
+ * "heading[level=2]" or "paragraph:first-child"
+ *
+ * Implementation Note: this file exports a very simple Selector class but all
+ * the actual work is done in various internal classes. The Parser class
+ * parses the string representation of a selector into a parse tree that
+ * consists of instances of various subclasses of the Selector class. It is
+ * these subclasses that implement the selector matching logic, often
+ * depending on features of the TraversalState object from the TreeTransformer
+ * traversal.
+ */
+import type { TreeNode, TraversalState } from "./tree-transformer";
+/**
+ * This is the base class for all Selector types. The key method that all
+ * selector subclasses must implement is match(). It takes a TraversalState
+ * object (from a TreeTransformer traversal) and tests whether the selector
+ * matches at the current node. See the comment at the start of this file for
+ * more details on the match() method.
+ */
+export default class Selector {
+    static parse(selectorText: string): Selector;
+    /**
+     * Return an array of the nodes that matched or null if no match.
+     * This is the base class so we just throw an exception. All Selector
+     * subclasses must provide an implementation of this method.
+     */
+    match(state: TraversalState): ReadonlyArray<TreeNode> | null | undefined;
+    /**
+     * Selector subclasses all define a toString() method primarily
+     * because it makes it easy to write parser tests.
+     */
+    toString(): string;
+}

package/dist/selector.js.flow

@@ -0,0 +1,31 @@
+/**
+ * Flowtype definitions for data
+ * Generated by Flowgen from a Typescript Definition
+ * Flowgen v1.21.0
+ * @flow
+ */
+import type { TreeNode, TraversalState } from "./tree-transformer";
+
+/**
+ * This is the base class for all Selector types. The key method that all
+ * selector subclasses must implement is match(). It takes a TraversalState
+ * object (from a TreeTransformer traversal) and tests whether the selector
+ * matches at the current node. See the comment at the start of this file for
+ * more details on the match() method.
+ */
+declare export default class Selector {
+  static parse(selectorText: string): Selector;
+
+  /**
+   * Return an array of the nodes that matched or null if no match.
+   * This is the base class so we just throw an exception. All Selector
+   * subclasses must provide an implementation of this method.
+   */
+  match(state: TraversalState): $ReadOnlyArray<TreeNode> | null | void;
+
+  /**
+   * Selector subclasses all define a toString() method primarily
+   * because it makes it easy to write parser tests.
+   */
+  toString(): string;
+}

package/dist/tree-transformer.d.ts

@@ -0,0 +1,205 @@
+/**
+ * TreeTransformer is a class for traversing and transforming trees.  Create a
+ * TreeTransformer by passing the root node of the tree to the
+ * constructor. Then traverse that tree by calling the traverse() method. The
+ * argument to traverse() is a callback function that will be called once for
+ * each node in the tree. This is a post-order depth-first traversal: the
+ * callback is not called on the a way down, but on the way back up. That is,
+ * the children of a node are traversed before the node itself is.
+ *
+ * The traversal callback function is passed three arguments, the node being
+ * traversed, a TraversalState object, and the concatentated text content of
+ * the node and all of its descendants. The TraversalState object is the most
+ * most interesting argument: it has methods for querying the ancestors and
+ * siblings of the node, and for deleting or replacing the node. These
+ * transformation methods are why this class is a tree transformer and not
+ * just a tree traverser.
+ *
+ * A typical tree traversal looks like this:
+ *
+ *   new TreeTransformer(root).traverse((node, state, content) => {
+ *       let parent = state.parent();
+ *       let previous = state.previousSibling();
+ *       // etc.
+ *   });
+ *
+ * The traverse() method descends through nodes and arrays of nodes and calls
+ * the traverse callback on each node on the way back up to the root of the
+ * tree. (Note that it only calls the callback on the nodes themselves, not
+ * any arrays that contain nodes.) A node is loosely defined as any object
+ * with a string-valued `type` property. Objects that do not have a type
+ * property are assumed to not be part of the tree and are not traversed. When
+ * traversing an array, all elements of the array are examined, and any that
+ * are nodes or arrays are recursively traversed. When traversing a node, all
+ * properties of the object are examined and any node or array values are
+ * recursively traversed.  In typical parse trees, the children of a node are
+ * in a `children` or `content` array, but this class is designed to handle
+ * more general trees.  The Perseus markdown parser, for example, produces
+ * nodes of type "table" that have children in the `header` and `cells`
+ * properties.
+ *
+ * CAUTION: the traverse() method does not make any attempt to detect
+ * cycles. If you call it on a cyclic graph instead of a tree, it will cause
+ * infinite recursion (or, more likely, a stack overflow).
+ *
+ * TODO(davidflanagan): it probably wouldn't be hard to detect cycles: when
+ * pushing a new node onto the containers stack we could just check that it
+ * isn't already there.
+ *
+ * If a node has a text-valued `content` property, it is taken to be the
+ * plain-text content of the node. The traverse() method concatenates these
+ * content strings and passes them to the traversal callback for each
+ * node. This means that the callback has access the full text content of its
+ * node and all of the nodes descendants.
+ *
+ * See the TraversalState class for more information on what information and
+ * methods are available to the traversal callback.
+ **/
+export type TreeNode = {
+    type: string;
+};
+export type TraversalCallback = (node: TreeNode, state: TraversalState, content: string) => void;
+export default class TreeTransformer {
+    root: TreeNode;
+    constructor(root: TreeNode);
+    static isNode(n: any): boolean;
+    static isTextNode(n: any): boolean;
+    traverse(f: TraversalCallback): void;
+    _traverse(n: TreeNode | Array<TreeNode>, state: TraversalState, f: TraversalCallback): string;
+}
+/**
+ * This class represents the state of a tree traversal. An instance is created
+ * by the traverse() method of the TreeTransformer class to maintain the state
+ * for that traversal, and the instance is passed to the traversal callback
+ * function for each node that is traversed. This class is not intended to be
+ * instantiated directly, but is exported so that its type can be used for
+ * Flow annotaions.
+ **/
+export declare class TraversalState {
+    root: TreeNode;
+    _currentNode: TreeNode | null | undefined;
+    _containers: Stack<TreeNode | Array<TreeNode>>;
+    _indexes: Stack<string | number>;
+    _ancestors: Stack<TreeNode>;
+    constructor(root: TreeNode);
+    /**
+     * Return the current node in the traversal. Any time the traversal
+     * callback is called, this method will return the name value as the
+     * first argument to the callback.
+     */
+    currentNode(): TreeNode;
+    /**
+     * Return the parent of the current node, if there is one, or null.
+     */
+    parent(): TreeNode | null | undefined;
+    /**
+     * Return an array of ancestor nodes. The first element of this array is
+     * the same as this.parent() and the last element is the root node. If we
+     * are currently at the root node, the the returned array will be empty.
+     * This method makes a copy of the internal state, so modifications to the
+     * returned array have no effect on the traversal.
+     */
+    ancestors(): ReadonlyArray<TreeNode>;
+    /**
+     * Return the next sibling of this node, if it has one, or null otherwise.
+     */
+    nextSibling(): TreeNode | null | undefined;
+    /**
+     * Return the previous sibling of this node, if it has one, or null
+     * otherwise.
+     */
+    previousSibling(): TreeNode | null | undefined;
+    /**
+     * Remove the next sibling node (if there is one) from the tree.  Returns
+     * the removed sibling or null. This method makes it easy to traverse a
+     * tree and concatenate adjacent text nodes into a single node.
+     */
+    removeNextSibling(): TreeNode | null | undefined;
+    /**
+     * Replace the current node in the tree with the specified nodes.  If no
+     * nodes are passed, this is a node deletion. If one node (or array) is
+     * passed, this is a 1-for-1 replacement. If more than one node is passed
+     * then this is a combination of deletion and insertion.  The new node or
+     * nodes will not be traversed, so this method can safely be used to
+     * reparent the current node node beneath a new parent.
+     *
+     * This method throws an error if you attempt to replace the root node of
+     * the tree.
+     */
+    replace(...replacements: ReadonlyArray<TreeNode>): void;
+    /**
+     * Returns true if the current node has a previous sibling and false
+     * otherwise. If this method returns false, then previousSibling() will
+     * return null, and goToPreviousSibling() will throw an error.
+     */
+    hasPreviousSibling(): boolean;
+    /**
+     * Modify this traversal state object to have the state it would have had
+     * when visiting the previous sibling. Note that you may want to use
+     * clone() to make a copy before modifying the state object like this.
+     * This mutator method is not typically used during ordinary tree
+     * traversals, but is used by the Selector class for matching multi-node
+     * selectors.
+     */
+    goToPreviousSibling(): void;
+    /**
+     * Returns true if the current node has an ancestor and false otherwise.
+     * If this method returns false, then the parent() method will return
+     * null and goToParent() will throw an error
+     */
+    hasParent(): boolean;
+    /**
+     * Modify this object to look like it will look when we (later) visit the
+     * parent node of this node. You should not modify the instance passed to
+     * the tree traversal callback. Instead, make a copy with the clone()
+     * method and modify that.  This mutator method is not typically used
+     * during ordinary tree traversals, but is used by the Selector class for
+     * matching multi-node selectors that involve parent and ancestor
+     * selectors.
+     */
+    goToParent(): void;
+    /**
+     * Return a new TraversalState object that is a copy of this one.
+     * This method is useful in conjunction with the mutating methods
+     * goToParent() and goToPreviousSibling().
+     */
+    clone(): TraversalState;
+    /**
+     * Returns true if this TraversalState object is equal to that
+     * TraversalState object, or false otherwise. This method exists
+     * primarily for use by our unit tests.
+     */
+    equals(that: TraversalState): boolean;
+}
+/**
+ * This class is an internal utility that just treats an array as a stack
+ * and gives us a top() method so we don't have to write expressions like
+ * `ancestors[ancestors.length-1]`. The values() method automatically
+ * copies the internal array so we don't have to worry about client code
+ * modifying our internal stacks. The use of this Stack abstraction makes
+ * the TraversalState class simpler in a number of places.
+ */
+declare class Stack<T> {
+    stack: Array<T>;
+    constructor(array?: ReadonlyArray<T> | null);
+    /** Push a value onto the stack. */
+    push(v: T): void;
+    /** Pop a value off of the stack. */
+    pop(): T;
+    /** Return the top value of the stack without popping it. */
+    top(): T;
+    /** Return a copy of the stack as an array */
+    values(): ReadonlyArray<T>;
+    /** Return the number of elements in the stack */
+    size(): number;
+    /** Return a string representation of the stack */
+    toString(): string;
+    /** Return a shallow copy of the stack */
+    clone(): Stack<T>;
+    /**
+     * Compare this stack to another and return true if the contents of
+     * the two arrays are the same.
+     */
+    equals(that: Stack<T>): boolean;
+}
+export {};