Accueil Compte

Votre panier : 0,00 €

Recevez notre lettre d'informations.

Je m'abonne

Je me désabonne

Déjà client ? Entrez votre e-mail et mot de passe :Première visite ?Enregistrez-vous

Code promotionnel

Promotions

Produit 1

25.90 €

Produit 2

12.90 €

(1)

QUI SOMMES NOUS ?

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  targ

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

et: null,
 };

 constructor(props) {
 super(props);
 this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
 const { mountTarget, onLoad } = this.props;
 const iframe = this.iframeRef.current;
 const doc = iframe.contentDocument;

 if (onLoad) {
 onLoad({
 document: this.iframeRef.current.contentDocument,
 window: this.iframeRef.current.contentWindow,
 });
 }

 const content = doc.querySelector(mountTarget);

 // clean mount Target
 if (content) {
 content.innerHTML = '';

 this.setState({
 ready: true,
 target: content,
 });
 }
 };

 render() {
 const { src, className } = this.props;
 const { ready, target } = this.state;

 return (
 <>
 <iframe
 className={className}
 ref={this.iframeRef}
 src={src}
 onLoad={this.handleOnLoadIframe}
 style={{ width: '100%', height: '100%', border: '0 none' }}
 />
 {ready &&
 ReactDOM.createPortal(
 this.props.content({
 document: this.iframeRef.current.contentDocument,
 window: this.iframeRef.current.contentWindow,
 }),
 target
 )}
 </>
 );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

Cliquez ici pour modifier le texte.

NOTRE ADRESSE

Adresse postale

Code postakiil - Ville

Pays

NOUS CONTACTER

Tel : 01.23.45.67.89

Fax : 01.23.45.67.89

Mail : contact@votresite.com

HORAIRES D'OUVERTURES

Lundi :

09:00-12:00 / 14:00-18:00

Mardi :

09:00-12:00 / 14:00-18:00

Mercredi :

09:00-12:00 / 14:00-18:00

Jeudi :

09:00-12:00 / 14:00-18:00

Vendredi :

09:00-12:00 / 14:00-18:00

DESCRIPTION

Duis autem vel eum iriure dolor in hendrerit in vulputate velit esse molestie consequat

Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takim

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

import React, { Component } from 'react';
import ReactDOM from 'react-dom';

class OxFrame extends Component {
 state = {
  ready: false,
  target: null,
 };

 constructor(props) {
  super(props);
  this.iframeRef = React.createRef();
 }

 handleOnLoadIframe = () => {
  const { mountTarget, onLoad } = this.props;
  const iframe = this.iframeRef.current;
  const doc = iframe.contentDocument;

  if (onLoad) {
   onLoad({
    document: this.iframeRef.current.contentDocument,
    window: this.iframeRef.current.contentWindow,
   });
  }

  const content = doc.querySelector(mountTarget);

  // clean mount Target
  if (content) {
   content.innerHTML = '';

   this.setState({
    ready: true,
    target: content,
   });
  }
 };

 render() {
  const { src, className } = this.props;
  const { ready, target } = this.state;

  return (
   <>
    <iframe
     className={className}
     ref={this.iframeRef}
     src={src}
     onLoad={this.handleOnLoadIframe}
     style={{ width: '100%', height: '100%', border: '0 none' }}
    />
    {ready &&
     ReactDOM.createPortal(
      this.props.content({
       document: this.iframeRef.current.contentDocument,
       window: this.iframeRef.current.contentWindow,
      }),
      target
     )}
   </>
  );
 }
}

export default OxFrame;

ata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet.

INFORMATIONS SUPPLEMENTAIRES

Duis autem vel eum iriure dolor in hendrerit in vulputate velit esse molestie consequat

- Lorem ipsum dolor sit amet, consetetur sadipscing elitr

- Sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua.

- At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est

- Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr

- sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat

Oxatis - création sites E-Commerce