rails_modular_admin 0.3.1 → 0.4.0

data/app/assets/node_modules/parchment/src/collection/linked-list.ts

@@ -0,0 +1,143 @@
+import LinkedNode from './linked-node';
+
+class LinkedList<T extends LinkedNode> {
+  head: T | null;
+  tail: T | null;
+  length: number;
+
+  constructor() {
+    this.head = this.tail = null;
+    this.length = 0;
+  }
+
+  append(...nodes: T[]): void {
+    this.insertBefore(nodes[0], null);
+    if (nodes.length > 1) {
+      this.append.apply(this, nodes.slice(1));
+    }
+  }
+
+  contains(node: T): boolean {
+    let cur,
+      next = this.iterator();
+    while ((cur = next())) {
+      if (cur === node) return true;
+    }
+    return false;
+  }
+
+  insertBefore(node: T | null, refNode: T | null): void {
+    if (!node) return
+    node.next = refNode;
+    if (refNode != null) {
+      node.prev = refNode.prev;
+      if (refNode.prev != null) {
+        refNode.prev.next = node;
+      }
+      refNode.prev = node;
+      if (refNode === this.head) {
+        this.head = node;
+      }
+    } else if (this.tail != null) {
+      this.tail.next = node;
+      node.prev = this.tail;
+      this.tail = node;
+    } else {
+      node.prev = null;
+      this.head = this.tail = node;
+    }
+    this.length += 1;
+  }
+
+  offset(target: T): number {
+    let index = 0,
+      cur = this.head;
+    while (cur != null) {
+      if (cur === target) return index;
+      index += cur.length();
+      cur = <T>cur.next;
+    }
+    return -1;
+  }
+
+  remove(node: T): void {
+    if (!this.contains(node)) return;
+    if (node.prev != null) node.prev.next = node.next;
+    if (node.next != null) node.next.prev = node.prev;
+    if (node === this.head) this.head = <T>node.next;
+    if (node === this.tail) this.tail = <T>node.prev;
+    this.length -= 1;
+  }
+
+  iterator(curNode: T | null = this.head): () => T | null {
+    // TODO use yield when we can
+    return function(): T | null {
+      let ret = curNode;
+      if (curNode != null) curNode = <T>curNode.next;
+      return ret;
+    };
+  }
+
+  find(index: number, inclusive: boolean = false): [T | null, number] {
+    let cur,
+      next = this.iterator();
+    while ((cur = next())) {
+      let length = cur.length();
+      if (
+        index < length ||
+        (inclusive && index === length && (cur.next == null || cur.next.length() !== 0))
+      ) {
+        return [cur, index];
+      }
+      index -= length;
+    }
+    return [null, 0];
+  }
+
+  forEach(callback: (cur: T) => void): void {
+    let cur,
+      next = this.iterator();
+    while ((cur = next())) {
+      callback(cur);
+    }
+  }
+
+  forEachAt(
+    index: number,
+    length: number,
+    callback: (cur: T, offset: number, length: number) => void,
+  ): void {
+    if (length <= 0) return;
+    let [startNode, offset] = this.find(index);
+    let cur,
+      curIndex = index - offset,
+      next = this.iterator(startNode);
+    while ((cur = next()) && curIndex < index + length) {
+      let curLength = cur.length();
+      if (index > curIndex) {
+        callback(cur, index - curIndex, Math.min(length, curIndex + curLength - index));
+      } else {
+        callback(cur, 0, Math.min(curLength, index + length - curIndex));
+      }
+      curIndex += curLength;
+    }
+  }
+
+  map(callback: (cur: T | null) => any): any[] {
+    return this.reduce(function(memo: (T | null)[], cur: T | null) {
+      memo.push(callback(cur));
+      return memo;
+    }, []);
+  }
+
+  reduce<M>(callback: (memo: M, cur: T) => M, memo: M): M {
+    let cur,
+      next = this.iterator();
+    while ((cur = next())) {
+      memo = callback(memo, cur);
+    }
+    return memo;
+  }
+}
+
+export default LinkedList;

data/app/assets/node_modules/parchment/src/collection/linked-node.ts

@@ -0,0 +1,8 @@
+interface LinkedNode {
+  prev: LinkedNode | null;
+  next: LinkedNode | null;
+
+  length(): number;
+}
+
+export default LinkedNode;

data/app/assets/node_modules/parchment/src/parchment.ts

@@ -0,0 +1,46 @@
+import { Blot } from './blot/abstract/blot';
+import ContainerBlot from './blot/abstract/container';
+import FormatBlot from './blot/abstract/format';
+import LeafBlot from './blot/abstract/leaf';
+
+import ScrollBlot from './blot/scroll';
+import InlineBlot from './blot/inline';
+import BlockBlot from './blot/block';
+import EmbedBlot from './blot/embed';
+import TextBlot from './blot/text';
+
+import Attributor from './attributor/attributor';
+import ClassAttributor from './attributor/class';
+import StyleAttributor from './attributor/style';
+import AttributorStore from './attributor/store';
+
+import * as Registry from './registry';
+
+let Parchment = {
+  Scope: Registry.Scope,
+
+  create: Registry.create,
+  find: Registry.find,
+  query: Registry.query,
+  register: Registry.register,
+
+  Container: ContainerBlot,
+  Format: FormatBlot,
+  Leaf: LeafBlot,
+  Embed: EmbedBlot,
+
+  Scroll: ScrollBlot,
+  Block: BlockBlot,
+  Inline: InlineBlot,
+  Text: TextBlot,
+
+  Attributor: {
+    Attribute: Attributor,
+    Class: ClassAttributor,
+    Style: StyleAttributor,
+
+    Store: AttributorStore,
+  },
+};
+
+export default Parchment;

data/app/assets/node_modules/parchment/src/registry.ts

@@ -0,0 +1,133 @@
+import Attributor from './attributor/attributor';
+import { Blot, Formattable } from './blot/abstract/blot';
+
+export interface BlotConstructor {
+  blotName: string;
+  new (node: Node, value?: any): Blot;
+  create(value?: any): Node;
+}
+
+export class ParchmentError extends Error {
+  message: string;
+  name: string;
+  stack!: string;
+
+  constructor(message: string) {
+    message = '[Parchment] ' + message;
+    super(message);
+    this.message = message;
+    this.name = (<any>this.constructor).name;
+  }
+}
+
+let attributes: { [key: string]: Attributor } = {};
+let classes: { [key: string]: BlotConstructor } = {};
+let tags: { [key: string]: BlotConstructor } = {};
+let types: { [key: string]: Attributor | BlotConstructor } = {};
+
+export const DATA_KEY = '__blot';
+
+export enum Scope {
+  TYPE = (1 << 2) - 1, // 0011 Lower two bits
+  LEVEL = ((1 << 2) - 1) << 2, // 1100 Higher two bits
+
+  ATTRIBUTE = (1 << 0) | LEVEL, // 1101
+  BLOT = (1 << 1) | LEVEL, // 1110
+  INLINE = (1 << 2) | TYPE, // 0111
+  BLOCK = (1 << 3) | TYPE, // 1011
+
+  BLOCK_BLOT = BLOCK & BLOT, // 1010
+  INLINE_BLOT = INLINE & BLOT, // 0110
+  BLOCK_ATTRIBUTE = BLOCK & ATTRIBUTE, // 1001
+  INLINE_ATTRIBUTE = INLINE & ATTRIBUTE, // 0101
+
+  ANY = TYPE | LEVEL,
+}
+
+export function create(input: Node | string | Scope, value?: any): Blot {
+  let match = query(input);
+  if (match == null) {
+    throw new ParchmentError(`Unable to create ${input} blot`);
+  }
+  let BlotClass = <BlotConstructor>match;
+  let node =
+    // @ts-ignore
+    input instanceof Node || input['nodeType'] === Node.TEXT_NODE ? input : BlotClass.create(value);
+  return new BlotClass(<Node>node, value);
+}
+
+export function find(node: Node | null, bubble: boolean = false): Blot | null {
+  if (node == null) return null;
+  // @ts-ignore
+  if (node[DATA_KEY] != null) return node[DATA_KEY].blot;
+  if (bubble) return find(node.parentNode, bubble);
+  return null;
+}
+
+export function query(
+  query: string | Node | Scope,
+  scope: Scope = Scope.ANY,
+): Attributor | BlotConstructor | null {
+  let match;
+  if (typeof query === 'string') {
+    match = types[query] || attributes[query];
+    // @ts-ignore
+  } else if (query instanceof Text || query['nodeType'] === Node.TEXT_NODE) {
+    match = types['text'];
+  } else if (typeof query === 'number') {
+    if (query & Scope.LEVEL & Scope.BLOCK) {
+      match = types['block'];
+    } else if (query & Scope.LEVEL & Scope.INLINE) {
+      match = types['inline'];
+    }
+  } else if (query instanceof HTMLElement) {
+    let names = (query.getAttribute('class') || '').split(/\s+/);
+    for (let i in names) {
+      match = classes[names[i]];
+      if (match) break;
+    }
+    match = match || tags[query.tagName];
+  }
+  if (match == null) return null;
+  // @ts-ignore
+  if (scope & Scope.LEVEL & match.scope && scope & Scope.TYPE & match.scope) return match;
+  return null;
+}
+
+export function register(...Definitions: any[]): any {
+  if (Definitions.length > 1) {
+    return Definitions.map(function(d) {
+      return register(d);
+    });
+  }
+  let Definition = Definitions[0];
+  if (typeof Definition.blotName !== 'string' && typeof Definition.attrName !== 'string') {
+    throw new ParchmentError('Invalid definition');
+  } else if (Definition.blotName === 'abstract') {
+    throw new ParchmentError('Cannot register abstract class');
+  }
+  types[Definition.blotName || Definition.attrName] = Definition;
+  if (typeof Definition.keyName === 'string') {
+    attributes[Definition.keyName] = Definition;
+  } else {
+    if (Definition.className != null) {
+      classes[Definition.className] = Definition;
+    }
+    if (Definition.tagName != null) {
+      if (Array.isArray(Definition.tagName)) {
+        Definition.tagName = Definition.tagName.map(function(tagName: string) {
+          return tagName.toUpperCase();
+        });
+      } else {
+        Definition.tagName = Definition.tagName.toUpperCase();
+      }
+      let tagNames = Array.isArray(Definition.tagName) ? Definition.tagName : [Definition.tagName];
+      tagNames.forEach(function(tag: string) {
+        if (tags[tag] == null || Definition.className == null) {
+          tags[tag] = Definition;
+        }
+      });
+    }
+  }
+  return Definition;
+}

data/app/assets/node_modules/parchment/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es5",
+    "declaration": true,
+    "strict": true
+  },
+  "exclude": ["node_modules", "test"]
+}

data/app/assets/node_modules/popper.js/README.md

@@ -0,0 +1,219 @@
+<!-- IGNORE THE HTML BLOCK BELOW, THE INTERESTING PART IS AFTER IT -->
+
+<h1 align="center">Popper.js</h1>
+
+<p align="center">
+    <strong>A library used to position poppers in web applications.</strong>
+</p>
+
+<p align="center">
+    <a href="https://travis-ci.org/FezVrasta/popper.js/branches" target="_blank"><img src="https://travis-ci.org/FezVrasta/popper.js.svg?branch=master" alt="Build Status"/></a>
+    <img src="http://img.badgesize.io/https://unpkg.com/popper.js/dist/popper.min.js?compression=gzip" alt="Stable Release Size"/>
+    <a href="https://www.bithound.io/github/FezVrasta/popper.js"><img src="https://www.bithound.io/github/FezVrasta/popper.js/badges/score.svg" alt="bitHound Overall Score"></a>
+    <a href="https://codeclimate.com/github/FezVrasta/popper.js/coverage"><img src="https://codeclimate.com/github/FezVrasta/popper.js/badges/coverage.svg" alt="Istanbul Code Coverage"/></a>
+    <a href="https://gitter.im/FezVrasta/popper.js" target="_blank"><img src="https://img.shields.io/gitter/room/nwjs/nw.js.svg" alt="Get support or discuss"/></a>
+    <br />
+    <a href="https://saucelabs.com/u/popperjs" target="_blank"><img src="https://badges.herokuapp.com/browsers?labels=none&googlechrome=latest&firefox=latest&microsoftedge=latest&iexplore=11,10&safari=latest&iphone=latest" alt="SauceLabs Reports"/></a>
+</p>
+
+<img src="https://raw.githubusercontent.com/FezVrasta/popper.js/master/popperjs.png" align="right" width=250 />
+
+<!-- 🚨 HEY! HERE BEGINS THE INTERESTING STUFF 🚨 -->
+
+## Wut? Poppers?
+
+A popper is an element on the screen which "pops out" from the natural flow of your application.  
+Common examples of poppers are tooltips, popovers and drop-downs.
+
+
+## So, yet another tooltip library?
+
+Well, basically, **no**.  
+Popper.js is a **positioning engine**, its purpose is to calculate the position of an element
+to make it possible to position it near a given reference element.  
+
+The engine is completely modular and most of its features are implemented as **modifiers**
+(similar to middlewares or plugins).  
+The whole code base is written in ES2015 and its features are automatically tested on real browsers thanks to [SauceLabs](https://saucelabs.com/) and [TravisCI](https://travis-ci.org/).
+
+Popper.js has zero dependencies. No jQuery, no LoDash, nothing.  
+It's used by big companies like [Twitter in Bootstrap v4](https://getbootstrap.com/), [Microsoft in WebClipper](https://github.com/OneNoteDev/WebClipper) and [Atlassian in AtlasKit](https://aui-cdn.atlassian.com/atlaskit/registry/).
+
+### Popper.js
+
+This is the engine, the library that computes and, optionally, applies the styles to
+the poppers.
+
+Some of the key points are:
+
+- Position elements keeping them in their original DOM context (doesn't mess with your DOM!);
+- Allows to export the computed informations to integrate with React and other view libraries;
+- Supports Shadow DOM elements;
+- Completely customizable thanks to the modifiers based structure;
+
+Visit our [project page](https://fezvrasta.github.io/popper.js) to see a lot of examples of what you can do with Popper.js!
+
+Find [the documentation here](/docs/_includes/popper-documentation.md).
+
+
+### Tooltip.js
+
+Since lots of users just need a simple way to integrate powerful tooltips in their projects,
+we created **Tooltip.js**.  
+It's a small library that makes it easy to automatically create tooltips using as engine Popper.js.  
+Its API is almost identical to the famous tooltip system of Bootstrap, in this way it will be
+easy to integrate it in your projects.  
+The tooltips generated by Tooltip.js are accessible thanks to the `aria` tags.
+
+Find [the documentation here](/docs/_includes/tooltip-documentation.md).
+
+
+## Installation
+Popper.js is available on the following package managers and CDNs:
+
+| Source |                                                                                  |
+|:-------|:---------------------------------------------------------------------------------|
+| npm    | `npm install popper.js --save`                                                   |
+| yarn   | `yarn add popper.js`                                                             |
+| NuGet  | `PM> Install-Package popper.js`                                                  |
+| Bower  | `bower install popper.js --save`                     |
+| unpkg  | [`https://unpkg.com/popper.js`](https://unpkg.com/popper.js)                     |
+| cdnjs  | [`https://cdnjs.com/libraries/popper.js`](https://cdnjs.com/libraries/popper.js) |
+
+Tooltip.js as well:
+
+| Source |                                                                                  |
+|:-------|:---------------------------------------------------------------------------------|
+| npm    | `npm install tooltip.js --save`                                                  |
+| yarn   | `yarn add tooltip.js`                                                            |
+| Bower* | `bower install tooltip.js=https://unpkg.com/tooltip.js --save`                   |
+| unpkg  | [`https://unpkg.com/tooltip.js`](https://unpkg.com/tooltip.js)                   |
+| cdnjs  | [`https://cdnjs.com/libraries/popper.js`](https://cdnjs.com/libraries/popper.js) |
+
+\*: Bower isn't officially supported, it can be used to install Tooltip.js only trough the unpkg.com CDN. This method has the limitation of not being able to define a specific version of the library. Bower and Popper.js suggests to use npm or Yarn for your projects.  
+For more info, [read the related issue](https://github.com/FezVrasta/popper.js/issues/390).
+
+### Dist targets
+
+Popper.js is currently shipped with 3 targets in mind: UMD, ESM and ESNext.
+
+- UMD - Universal Module Definition: AMD, RequireJS and globals;
+- ESM - ES Modules: For webpack/Rollup or browser supporting the spec;
+- ESNext: Available in `dist/`, can be used with webpack and `babel-preset-env`;
+
+Make sure to use the right one for your needs. If you want to import it with a `<script>` tag, use UMD.
+
+## Usage
+
+Given an existing popper DOM node, ask Popper.js to position it near its button
+
+```js
+var reference = document.querySelector('.my-button');
+var popper = document.querySelector('.my-popper');
+var anotherPopper = new Popper(
+    reference,
+    popper,
+    {
+        // popper options here
+    }
+);
+```
+
+### Callbacks
+
+Popper.js supports two kinds of callbacks, the `onCreate` callback is called after
+the popper has been initalized. The `onUpdate` one is called on any subsequent update.
+
+```js
+const reference = document.querySelector('.my-button');
+const popper = document.querySelector('.my-popper');
+new Popper(reference, popper, {
+    onCreate: (data) => {
+        // data is an object containing all the informations computed
+        // by Popper.js and used to style the popper and its arrow
+        // The complete description is available in Popper.js documentation
+    },
+    onUpdate: (data) => {
+        // same as `onCreate` but called on subsequent updates
+    }
+});
+```
+
+### Writing your own modifiers
+
+Popper.js is based on a "plugin-like" architecture, most of its features are fully encapsulated "modifiers".  
+A modifier is a function that is called each time Popper.js needs to compute the position of the popper. For this reason, modifiers should be very performant to avoid bottlenecks.  
+
+To learn how to create a modifier, [read the modifiers documentation](docs/_includes/popper-documentation.md#modifiers--object)
+
+
+### React, Vue.js, Angular, AngularJS, Ember.js (etc...) integration
+
+Integrating 3rd party libraries in React or other libraries can be a pain because
+they usually alter the DOM and drive the libraries crazy.  
+Popper.js limits all its DOM modifications inside the `applyStyle` modifier,
+you can simply disable it and manually apply the popper coordinates using
+your library of choice.  
+
+For a comprehensive list of libraries that let you use Popper.js into existing
+frameworks, visit the [MENTIONS](/MENTIONS.md) page.
+
+Alternatively, you may even override your own `applyStyles` with your custom one and
+integrate Popper.js by yourself!
+
+```js
+function applyReactStyle(data) {
+    // export data in your framework and use its content to apply the style to your popper
+};
+
+const reference = document.querySelector('.my-button');
+const popper = document.querySelector('.my-popper');
+new Popper(reference, popper, {
+    modifiers: {
+        applyStyle: { enabled: false },
+        applyReactStyle: {
+            enabled: true,
+            fn: applyReactStyle,
+            order: 800,
+        },
+    },
+});
+
+```
+
+### Migration from Popper.js v0
+
+Since the API changed, we prepared some migration instructions to make it easy to upgrade to
+Popper.js v1.  
+
+https://github.com/FezVrasta/popper.js/issues/62
+
+Feel free to comment inside the issue if you have any questions.
+
+### Performances
+
+Popper.js is very performant. It usually takes 0.5ms to compute a popper's position (on an iMac with 3.5G GHz Intel Core i5).  
+This means that it will not cause any [jank](https://www.chromium.org/developers/how-tos/trace-event-profiling-tool/anatomy-of-jank), leading to a smooth user experience.
+
+## Notes
+
+### Libraries using Popper.js
+
+The aim of Popper.js is to provide a stable and powerful positioning engine ready to
+be used in 3rd party libraries.  
+
+Visit the [MENTIONS](/MENTIONS.md) page for an updated list of projects.
+
+
+### Credits
+I want to thank some friends and projects for the work they did:
+
+- [@AndreaScn](https://github.com/AndreaScn) for his work on the GitHub Page and the manual testing he did during the development;
+- [@vampolo](https://github.com/vampolo) for the original idea and for the name of the library;
+- [Sysdig](https://github.com/Draios) for all the awesome things I learned during these years that made it possible for me to write this library;
+- [Tether.js](http://github.hubspot.com/tether/) for having inspired me in writing a positioning library ready for the real world;
+- [The Contributors](https://github.com/FezVrasta/popper.js/graphs/contributors) for their much appreciated Pull Requests and bug reports;
+- **you** for the star you'll give to this project and for being so awesome to give this project a try 🙂
+
+### Copyright and license
+Code and documentation copyright 2016 **Federico Zivolo**. Code released under the [MIT license](LICENSE.md). Docs released under Creative Commons.