├── .npmignore
├── .babelrc
├── .gitignore
├── assets
    └── ZeroClipboard.swf
├── package.json
├── loadScript.js
├── README.md
├── docs.js
├── index.html
└── index.js


/.npmignore:
--------------------------------------------------------------------------------
1 | index.html
2 | docs.js
3 | 


--------------------------------------------------------------------------------
/.babelrc:
--------------------------------------------------------------------------------
1 | {
2 |   "presets": ["react"]
3 | }
4 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | docs-bundle.js
3 | .idea/
4 | 


--------------------------------------------------------------------------------
/assets/ZeroClipboard.swf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/brigand/react-zeroclipboard/HEAD/assets/ZeroClipboard.swf


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "react-zeroclipboard",
 3 |   "version": "4.0.1",
 4 |   "description": "react component for zeroclipboard",
 5 |   "main": "index.js",
 6 |   "keywords": [
 7 |     "react",
 8 |     "clipboard",
 9 |     "react-component"
10 |   ],
11 |   "scripts": {
12 |     "test": "echo \"Error: no test specified\" && exit 1",
13 |     "docs": "npm run browserify",
14 |     "browserify": "browserify -d -t babelify docs.js -o docs-bundle.js"
15 |   },
16 |   "repository": "https://github.com/brigand/react-zeroclipboard.git",
17 |   "homepage": "http://brigand.github.io/react-zeroclipboard/",
18 |   "author": "Frankie Bagnardi <f.bagnardi@gmail.com>",
19 |   "license": "MIT",
20 |   "devDependencies": {
21 |     "babel-core": "^6.0.12",
22 |     "babel-preset-react": "^6.0.12",
23 |     "babelify": "^7.0.2",
24 |     "browserify": "^9.0.8",
25 |     "envify": "^3.4.0",
26 |     "react": "^0.14.0",
27 |     "react-dom": "^0.14.0"
28 |   },
29 |   "browserify": {
30 |     "transform": [
31 |       "envify"
32 |     ]
33 |   },
34 |   "dependencies": {
35 |     "create-react-class": "^15.5.3",
36 |     "envify": "^3"
37 |   }
38 | }
39 | 


--------------------------------------------------------------------------------
/loadScript.js:
--------------------------------------------------------------------------------
 1 | var loading = {};
 2 | 
 3 | module.exports = function loadScript(src, callback){
 4 |     if (typeof(window) === 'undefined') return;
 5 |     
 6 |     // we don't want duplicate script elements
 7 |     // so we use an array of callbacks instead of
 8 |     // multiple onload handlers
 9 |     if (loading[src]) {
10 |         loading[src].push(callback);
11 |         return;
12 |     }
13 | 
14 |     // create the array of callbacks
15 |     loading[src] = [callback];
16 | 
17 |     // create a script, and handle success/failure in node callback style
18 |     var script = document.createElement('script');
19 |     script.onload = function(){
20 |         loading[src].forEach(function(cb){
21 |             cb();
22 |         });
23 |         delete loading[src];
24 |     };
25 | 
26 |     script.onerror = function(error){
27 |         loading[src].forEach(function(cb){
28 |             cb(error)
29 |         });
30 |         delete loading[src];
31 |     };
32 | 
33 |     // set the src and append it to the head
34 |     // I believe async is true by default, but there's no harm in setting it
35 |     script.async = true;
36 |     script.src = src;
37 |     document.getElementsByTagName("head")[0].appendChild(script);
38 | };
39 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | 
  2 | ## react-zeroclipboard
  3 | 
  4 | This is a wrapper around ZeroClipboard for use with React.  ZeroClipboard has a difficult to work with api
  5 | which is being abstracted from you.  This library...
  6 | 
  7 | *   asynchronusly loads zeroclipboard from cdnjs
  8 | *   handles mounting/unmounting of components
  9 | *   figures out which element was clicked
 10 | *   allows you to declare text/html/rtf, or pass a function which returns it dynamically
 11 | 
 12 | ## Warning!
 13 | 
 14 | zero-clipboard uses flash which is being phased out across many browsers, and is sometimes buggy in the browsers that do support it. There have been reports of the plugin randomly not working, despite no significant changes to the plugin, and keeping the same zero-clipboard version.
 15 | 
 16 | If you're interested in solving this, your help is very much appreciated, and this section will be replaced with a big "thank you" for your work. Until then, using this plugin isn't recommended.
 17 | 
 18 | ### Install
 19 | 
 20 | This is only available through npm, it should work with browserify or webpack.  It's compatible with react 0.13 and up.
 21 | 
 22 | ```sh
 23 | npm install --save react-zeroclipboard
 24 | ```
 25 | 
 26 | Or for react 0.11 and 0.12
 27 | 
 28 | ```sh
 29 | npm install --save react-zeroclipboard@0.4
 30 | ```
 31 | 
 32 | Also install react if you haven't already (of course).
 33 | 
 34 | ### Usage
 35 | 
 36 | Here's a simple example:
 37 | 
 38 | ```js
 39 | render: function(){
 40 |    return (
 41 |       <div>
 42 |          <p>Click the button to copy some text</p>
 43 |             <ReactZeroClipboard text="Hello, world!">
 44 |                <button>Copy</button>
 45 |             </ReactZeroClipboard>
 46 |       </div>
 47 |    )
 48 | }
 49 | ```
 50 | 
 51 | The full api offers more flexibility.  If you provide e.g. html and text, they'll both be set and
 52 | the application you're pasting into decides which one to use.  Methods have higher priority than
 53 | the literal strings, if for some reason you pass both.
 54 | 
 55 | ```js
 56 | <ReactZeroClipboard 
 57 |    text="text to copy"
 58 |    html="<b>html to copy</b>"
 59 |    richText="{\\rtf1\\ansi\n{\\b rich text to copy}}"
 60 |    getText={(Void -> String)}
 61 |    getHtml={(Void -> String)}
 62 |    getRichText={(Void -> String)}
 63 | 
 64 |    onCopy={(Event -> Void)}
 65 |    onAfterCopy={(Event -> Void)}
 66 |    onErrorCopy={(Error -> Void)}
 67 | 
 68 |    onReady={(Event -> Void)}
 69 | 
 70 |    // optional
 71 |    swfPath="http://user_defined_cdn_path/ZeroClipboard.swf"
 72 | />
 73 | ```
 74 | 
 75 | Here's an example where we copy the current url to the clipboard, both in plain text and a html anchor
 76 | 
 77 | If the user pastes this in their address bar they get the url, and if they paste it in gmail they get a nice link.
 78 | 
 79 | ```js
 80 | render: function(){
 81 |    return (
 82 |       <div>
 83 |          <p>Copy a link to this page</p>
 84 |             <ReactZeroClipboard 
 85 |                getText={function(){ return location.href; }}
 86 |                getHtml={function(){ return '<a href="' + location.href + '">My Page</a>'; }}>
 87 |                   <button>Copy</button>
 88 |             </ReactZeroClipboard>
 89 |       </div>
 90 |    )
 91 | }
 92 | ```
 93 | 
 94 | ## I'm getting weird ZeroClipboard errors
 95 | 
 96 | Usually this is caused by flash weirdness and/or cdnjs where we pull ZeroClipboard from. You can work around this
 97 | by hosting ZeroClipboard and the swf yourself. Make sure the page and the two assets are either both http, or both
 98 | https. There's a copy of the swf in the assets directory of this repo.
 99 | 
100 | To access it with webpack, configure a loader for swf files:
101 | 
102 | ```js
103 | {
104 |   test: /\.swf$/g,
105 |   loader: 'file-loader'
106 | }
107 | ```
108 | 
109 | And then import the swf from this package.
110 | 
111 | ```jsx
112 | <ReactZeroClipboard swfPath={ require('react-zeroclipboard/assets/ZeroClipboard.swf') }>
113 | ```
114 | 


--------------------------------------------------------------------------------
/docs.js:
--------------------------------------------------------------------------------
  1 | var React = require('react');
  2 | var createReactClass = require('create-react-class');
  3 | var ReactDOM = require('react-dom');
  4 | var ReactZeroClipboard = require('./');
  5 | window.d = ReactDOM;
  6 | var npmInstallCommand = "npm install react-zeroclipboard";
  7 | var zclipProps = {
  8 |   swfPath: './assets/ZeroClipboard.swf'
  9 | };
 10 | 
 11 | NpmInstallLink = createReactClass({
 12 |     render: function(){
 13 |         return (
 14 |         <div className="input-group">
 15 |             <input className="form-control input-lg" value={npmInstallCommand} />      
 16 |             <ReactZeroClipboard text={npmInstallCommand} {...zclipProps}>
 17 |                 <span className="input-group-addon" style={{cursor: 'pointer'}}>Copy</span>
 18 |             </ReactZeroClipboard>
 19 |         </div>
 20 |         );
 21 |     }
 22 | });
 23 | ReactDOM.render(<NpmInstallLink />, document.getElementById("npm-install-link-target"));
 24 | 
 25 | 
 26 | 
 27 | var list = [
 28 |     "apples", "oranges", "bananas"
 29 | ];
 30 | 
 31 | var MultiTypeDemo = createReactClass({
 32 |     getText: function(){
 33 |         return list.map(function(x){ return "- " + x }).join("\n");
 34 |     },
 35 |     getHtml: function(){
 36 |         var items = list.map(function(x, i){
 37 |             if (i % 2) {
 38 |                 return "<li>" + x + "</li>" ;    
 39 |             }
 40 |             else {
 41 |                 return "<li class='even'>" + x + "</li>" ;
 42 |             }
 43 |             
 44 |         });
 45 |         return "<ul>" + items.join('\n') + "<ul>";
 46 |     },
 47 |     render: function(){
 48 |         return (
 49 |         <div>
 50 |             <ReactZeroClipboard getText={this.getText} getHtml={this.getHtml} {...zclipProps}>
 51 |                 <div className="btn">Copy List</div>
 52 |             </ReactZeroClipboard>
 53 |             <div className="row">
 54 |                 <div className="col-xs-6">
 55 |                     <textarea defaultValue="" placeholder="this is a textarea" />
 56 |                 </div>
 57 |                 <div className="col-xs-6">
 58 |                     <div contentEditable />
 59 |                 </div>
 60 |             </div>
 61 |         </div>
 62 |         );
 63 |     }
 64 | });
 65 | 
 66 | 
 67 | 
 68 | ReactDOM.render(<MultiTypeDemo />, document.getElementById("list-demo-target"));
 69 | 
 70 | var EventsDemo = createReactClass({
 71 |     getInitialState: function(){
 72 |         return {
 73 |             logs: [],
 74 |         };
 75 |     },
 76 |     getLogger: function(eventName){
 77 |         return function(event){
 78 |             var logs = this.state.logs.concat([{name: eventName, event: event}]);
 79 |             this.setState({logs: logs});
 80 |         }.bind(this);
 81 |     },
 82 |     render: function(){
 83 |         var styl = {
 84 |             padding: "10px", 
 85 |             border: "1px solid #eee",
 86 |             borderRadius: "7px"
 87 |         };
 88 |         
 89 |         return (
 90 |         <div>
 91 |             <div><ReactZeroClipboard text="example text" 
 92 |                 onCopy={this.getLogger("copy")}
 93 |                 onAfterCopy={this.getLogger("afterCopy")}
 94 |                 onError={this.getLogger("error")}
 95 |                 onReady={this.getLogger("ready")}
 96 |                 {...zclipProps}
 97 |                 >
 98 |                     <span>Click To Copy</span>
 99 |                 </ReactZeroClipboard></div>
100 |             <div style={styl}><ol>{this.state.logs.map(function(log, i){
101 |                 var out = {};
102 |                 
103 |                 for (var key in log.event) {
104 |                     if (log.event[key] instanceof window.Element) {
105 |                         out[key] = String(log.event[key]);
106 |                     }
107 |                     else {
108 |                         out[key] = log.event[key];
109 |                     }
110 |                 }
111 | 
112 | 
113 |                 return <li key={i}>{log.name}: <pre>{JSON.stringify(out, null, 4)}</pre></li>
114 |             })}</ol></div>
115 |         </div>
116 |         );
117 |     }
118 | });
119 | 
120 | ReactDOM.render(<EventsDemo />, document.getElementById("events-demo-target"));
121 | 


--------------------------------------------------------------------------------
/index.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html>
  3 | <head>
  4 |     <title>react-zeroclipboard</title>
  5 |     <link rel="stylesheet" type="text/css" href="//cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/3.2.0/css/bootstrap.css">
  6 | </head>
  7 | <body>
  8 | <div role="main" class="container">
  9 |     <div class="row">
 10 |         <div class="col-12">
 11 |             <h2 class="brand">react-zeroclipboard</h2>      
 12 |             <div id="app">
 13 |                 <form class="">
 14 |                     <div class="form-group" id="npm-install-link-target"></div>
 15 |                 </form>
 16 |                 <p>This is a wrapper around ZeroClipboard for use with React.  ZeroClipboard has a difficult to work with api
 17 |                 which is being abstracted from you.  This library...</p>
 18 |                 <ul>
 19 |                     <li>asynchronusly loads zeroclipboard from cdnjs</li>
 20 |                     <li>handles mounting/unmounting of components</li>
 21 |                     <li>figures out which element was clicked</li>
 22 |                     <li>allows you to declare text/html/rtf, or pass a function which returns it dynamically</li>
 23 |                 </ul>
 24 |                 <p>Here's a simple example:</p>
 25 |                 <pre><code>render: function(){
 26 |     return (
 27 |         &lt;div>
 28 |             &lt;p>Click the button to copy some text&lt;/p>
 29 |             &lt;ReactZeroClipboard text="Hello, world!">&lt;button>Copy&lt;/button>&lt;/ReactZeroClipboard>
 30 |         &lt;/div>
 31 |     )
 32 | }
 33 | </code></pre>
 34 | 
 35 |                 <p>The full api offers more flexibility.  If you provide e.g. html and text, they'll both be set and
 36 |                 the application you're pasting into decides which one to use.  Methods have higher priority than
 37 |                 the literal strings, if for some reason you pass both.</p>
 38 | 
 39 |                 <p>The events can be used to show a success message by changing state, focusing an input, or
 40 |                 anything you want to happen.  Generally you should use <code>onAfterCopy</code>.  The docs don't specify
 41 |                 when the error event occurs, or what can cause it.</p>
 42 | 
 43 |                 <pre><code> &lt;ReactZeroClipboard 
 44 |    text="text to copy"
 45 |    html="&lt;b>html to copy&lt;/b>"
 46 |    richText="{\\rtf1\\ansi\n{\\b rich text to copy}}"
 47 |    // optional 
 48 |    swfPath="http://user_defined_cdn_path/ZeroClipboard.swf"
 49 |    getText={(Void -> String)}
 50 |    getHtml={(Void -> String)}
 51 |    getRichText={(Void -> String)}
 52 |    onCopy={(Event -> Void)}
 53 |    onAfterCopy={(Event -> Void)}
 54 |    onErrorCopy={(Error -> Void)}
 55 |    onReady={(Error -> Void)}
 56 |  />
 57 | </code></pre>
 58 |              <p>Here's an example where we copy the current url to the clipboard, both in plain text and a html anchor</p>
 59 |              <p>If the user pastes this in their address bar they get the url, and if they paste it in gmail they get a nice link.</p>
 60 |                 <pre><code>render: function(){
 61 |     return (
 62 |         &lt;div>
 63 |             &lt;p>Copy a link to this page&lt;/p>
 64 |             &lt;ReactZeroClipboard 
 65 |                     getText={function(){ return location.href; }}
 66 |                     getHtml={function(){ return '&lt;a href="' + location.href + '">My Page&lt;/a>'; }}>
 67 |                         &lt;button>Copy&lt;/button>
 68 |             &lt;/ReactZeroClipboard>
 69 |         &lt;/div>
 70 |     )
 71 | }
 72 | </code></pre>
 73 |             <p>Here's a demo which shows how multiple types work.  Press the copy button, and then try pasting it into each of the boxes below.
 74 |             one is a textarea, and the other is a contentEditable.</p>
 75 |             <style>
 76 |                 #list-demo-target textarea, #list-demo-target [contenteditable] {
 77 |                     width: 100%;
 78 |                     height: 7em;
 79 |                     border: 1px solid black;
 80 |                     box-sizing: border-box;
 81 |                     padding: 1em;
 82 |                     outline: none;
 83 |                 }
 84 | 
 85 |                 #list-demo-target li.even {
 86 |                     background: rgba(0, 0, 0, 0.1);
 87 |                 }
 88 |             </style>
 89 |             <div id="list-demo-target"></div>
 90 |             </div>
 91 | 
 92 |             <p>This is simply a button which logs the events as they occur.</p>
 93 |             <div id="events-demo-target"></div>
 94 |         </div>
 95 |     </div>
 96 | </div>
 97 | <script src="docs-bundle.js"></script>
 98 | </body>
 99 | </html>
100 | 


--------------------------------------------------------------------------------
/index.js:
--------------------------------------------------------------------------------
  1 | var React = require('react');
  2 | var createReactClass = require('create-react-class');
  3 | var ReactDOM = require('react-dom');
  4 | var loadScript = require('./loadScript');
  5 | var ZeroClipboard, client;
  6 | 
  7 | // callbacks waiting for ZeroClipboard to load
  8 | var waitingForScriptToLoad = [];
  9 | 
 10 | // these are the active elements using ZeroClipboardComponent
 11 | // each item in the array should be a [element, callback] pair
 12 | var eventHandlers = {
 13 |     copy: [],
 14 |     afterCopy: [],
 15 |     error: [],
 16 |     ready: []
 17 | };
 18 | 
 19 | var ZERO_CLIPBOARD_SOURCE = '//cdnjs.cloudflare.com/ajax/libs/zeroclipboard/2.2.0/ZeroClipboard';
 20 | var globalConfig = {
 21 |     swfPath: '//cdnjs.cloudflare.com/ajax/libs/zeroclipboard/2.2.0/ZeroClipboard.swf',
 22 |     // load zeroclipboard from CDN
 23 |     // in production we want the minified version
 24 |     jsPath: process.env.NODE_ENV === 'production' ? ZERO_CLIPBOARD_SOURCE + '.min.js' : ZERO_CLIPBOARD_SOURCE + '.js'
 25 | };
 26 | 
 27 | // add a listener, and returns a remover
 28 | var addZeroListener = function(event, el, fn){
 29 |     eventHandlers[event].push([el, fn]);
 30 |     return function(){
 31 |         var handlers = eventHandlers[event];
 32 |         for (var i=0; i<handlers.length; i++) {
 33 |             if (handlers[i][0] === el) {
 34 |                 // mutate the array to remove the listener
 35 |                 handlers.splice(i, 1);
 36 |                 return;
 37 |             }
 38 |         }
 39 |     };
 40 | };
 41 | 
 42 | var propToEvent = {
 43 |     onCopy: 'copy',
 44 |     onAfterCopy: 'afterCopy',
 45 |     onError: 'error',
 46 |     onReady: 'ready'
 47 | };
 48 | 
 49 | var readyEventHasHappened = false;
 50 | 
 51 | // asynchronusly load ZeroClipboard from cdnjs
 52 | // it should automatically discover the SWF location using some clever hacks :-)
 53 | var handleZeroClipLoad = function(error){
 54 |     if (error) {
 55 |         console.error("Couldn't load zeroclipboard from CDNJS.  Copy will not work.  "
 56 |             + "Check your Content-Security-Policy.");
 57 |         console.error(error);
 58 |     }
 59 | 
 60 |     // grab it and free up the global
 61 |     ZeroClipboard = global.ZeroClipboard;
 62 |     delete global.ZeroClipboard;
 63 | 
 64 |     ZeroClipboard.config({
 65 |         swfPath: globalConfig.swfPath
 66 |     });
 67 | 
 68 |     client = new ZeroClipboard();
 69 | 
 70 |     var handleEvent = function(eventName){
 71 |         client.on(eventName, function(event){
 72 |             // ready has no active element
 73 |             if (eventName === 'ready') {
 74 |                 eventHandlers[eventName].forEach(function(xs){
 75 |                     xs[1](event);
 76 |                 });
 77 | 
 78 |                 readyEventHasHappened = true;
 79 |                 return;
 80 |             }
 81 | 
 82 |             var activeElement = ZeroClipboard.activeElement();
 83 | 
 84 |             // find an event handler for this element
 85 |             // we use some so we don't continue looking after a match is found
 86 |             eventHandlers[eventName].some(function(xs){
 87 |                 var element = xs[0], callback = xs[1];
 88 |                 if (element === activeElement) {
 89 |                     callback(event);
 90 |                     return true;
 91 |                 }
 92 |             });
 93 |         });
 94 |     };
 95 | 
 96 |     for (var eventName in eventHandlers) {
 97 |         handleEvent(eventName);
 98 |     }
 99 | 
100 |     // call the callbacks when ZeroClipboard is ready
101 |     // these are set in ReactZeroClipboard::componentDidMount
102 |     waitingForScriptToLoad.forEach(function(callback){
103 |         callback();
104 |     });
105 | };
106 | 
107 | var findOrLoadWasCalled = false;
108 | function findOrLoadZeroClipboard(){
109 |     if (findOrLoadWasCalled) return;
110 |     findOrLoadWasCalled = true;
111 | 
112 |     if (global.ZeroClipboard) {
113 |         handleZeroClipLoad(null);
114 |     }
115 |     else {
116 |         loadScript(globalConfig.jsPath, handleZeroClipLoad);
117 |     }
118 | }
119 | 
120 | function setUserDefinedSwfPath(path){
121 |   globalConfig = Object.assign(globalConfig, {swfPath: path})
122 | }
123 | 
124 | // <ReactZeroClipboard
125 | //   text="text to copy"
126 | //   html="<b>html to copy</b>"
127 | //   richText="{\\rtf1\\ansi\n{\\b rich text to copy}}"
128 | //   swfPath="http://user_defined_cdn_path/ZeroClipboard.swf"
129 | //   getText={(Void -> String)}
130 | //   getHtml={(Void -> String)}
131 | //   getRichText={(Void -> String)}
132 | //
133 | //   onCopy={(Event -> Void)}
134 | //   onAfterCopy={(Event -> Void)}
135 | //   onErrorCopy={(Error -> Void)}
136 | //
137 | //   onReady={(Event -> Void)}
138 | // />
139 | var ReactZeroClipboard = createReactClass({
140 |     ready: function(cb){
141 |         if (null != this.props.swfPath) {
142 |           setUserDefinedSwfPath(this.props.swfPath);
143 |         }
144 | 
145 |         findOrLoadZeroClipboard();
146 | 
147 |         if (client) {
148 |             // nextTick guarentees asynchronus execution
149 |             if (typeof process !== 'undefined' && process.nextTick) {
150 |               process.nextTick(cb.bind(this));
151 |             } else if (typeof setImmediate === 'function') {
152 |               setImmediate(cb.bind(this));
153 |             } else {
154 |               setTimeout(cb.bind(this), 0);
155 |             }
156 |         }
157 |         else {
158 |             waitingForScriptToLoad.push(cb.bind(this));
159 |         }
160 |     },
161 |     componentWillMount: function(){
162 |         if (readyEventHasHappened && this.props.onReady) {
163 |             this.props.onReady();
164 |         }
165 |     },
166 |     componentDidMount: function(){
167 |         // wait for ZeroClipboard to be ready, and then bind it to our element
168 |         this.eventRemovers = [];
169 |         this.ready(function(){
170 |             if (this.didUnmount) return;
171 |             var el = ReactDOM.findDOMNode(this);
172 |             client.clip(el);
173 | 
174 |             // translate our props to ZeroClipboard events, and add them to
175 |             // our listeners
176 |             for (var prop in this.props) {
177 |                 var eventName = propToEvent[prop];
178 | 
179 |                 if (eventName && typeof this.props[prop] === "function") {
180 |                     var remover = addZeroListener(eventName, el, this.props[prop]);
181 |                     this.eventRemovers.push(remover);
182 |                 }
183 |             }
184 | 
185 |             var remover = addZeroListener("copy", el, this.handleCopy);
186 |             this.eventRemovers.push(remover);
187 |         });
188 |     },
189 |     componentWillUnmount: function(){
190 |         this.didUnmount = true;
191 |         if (client) {
192 |             client.unclip(ReactDOM.findDOMNode(this));
193 |         }
194 | 
195 |         // remove our event listener
196 |         this.eventRemovers.forEach(function(fn){ fn(); });
197 |     },
198 |     handleCopy: function(){
199 |         var p = this.props;
200 | 
201 |         // grab or calculate the different data types
202 |         var text = result(p.getText || p.text);
203 |         var html = result(p.getHtml || p.html);
204 |         var richText = result(p.getRichText || p.richText);
205 | 
206 |         // give ourselves a fresh slate and then set
207 |         // any provided data types
208 |         client.clearData();
209 |         richText != null && client.setRichText(richText);
210 |         html     != null && client.setHtml(html);
211 |         text     != null && client.setText(text);
212 |     },
213 |     render: function(){
214 |         return React.Children.only(this.props.children);
215 |     }
216 | });
217 | 
218 | ReactZeroClipboard.globalConfig = globalConfig;
219 | 
220 | module.exports = ReactZeroClipboard;
221 | 
222 | function result(fnOrValue) {
223 |     if (typeof fnOrValue === "function") {
224 |         // call it if it's a function
225 |         return fnOrValue();
226 |     }
227 |     else {
228 |         // just return it as is
229 |         return fnOrValue;
230 |     }
231 | }
232 | 


--------------------------------------------------------------------------------