Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/prevwong/craft.js

🚀 A React Framework for building extensible drag and drop page editors
https://github.com/prevwong/craft.js

draft-js drag-and-drop html-builder page-builder react site-builder web-builder wysiwyg

Last synced: 10 days ago
JSON representation

🚀 A React Framework for building extensible drag and drop page editors

Awesome Lists containing this project

README 

        




craft.js




  










  






  

    Live Demo

  




Page editors are a great way to provide an excellent user experience. However, to build one is often a pretty dreadful task.



There're existing libraries that come with a fully working page editor out of the box with a user interface and editable components. However, if you wish to make customisations such as modifying the user interface and its behavior, it will most definitely involve modifying the library itself.



Craft.js solves this problem by modularising the building blocks of a page editor. It ships with a drag-n-drop system and handles the way user components should be rendered, updated and moved - among other things. With this, you'll be able to build your own page editor exactly how you want it to look and behave.



## Docs

- [Core concepts](https://craft.js.org/docs/concepts/nodes)

- [Tutorial](https://craft.js.org/docs/guides/basic-tutorial)

- [API Reference](https://craft.js.org/docs/api/editor-state)



## Examples

These examples should give you an idea on the flexibility of Craft.js.



Both these examples look very different from each other, with very different UI. But they are both built with Craft.js! 🤯



- [Landing](https://craft.js.org)

- [Basic](https://craft.js.org/examples/basic)



## Features :fire:

### It's just React

No need for complicated plugin systems. Design your editor from top to bottom the same way as you would design any other frontend application in React.



A simple user component can easily be defined as such:

```jsx

import { useNode } from "@craftjs/core";



const TextComponent = ({ text }) => {

  const {

    connectors: { connect, drag },

  } = useNode();



  return (

    
 connect(drag(ref))}>

      
{text}


    


  );

};



```



Heck, the entire UI of your page editor is built using just React.

```jsx

import React from "react";

import { Editor, Frame, Element  } from "@craftjs/core";

const App = () => {

  return (

    


      Some fancy header or whatever

      

        // Editable area starts here

        

          

        

      

    


  );

};

```



### Control how your components are edited

An obvious requirement for page editors is that they need to allow users to edit components. With Craft.js, you control the process of which these components should be edited.



In the following example, when the user clicks on a component, we'll display a modal that requires the user to input a value for the `text` prop. As the input value changes, the component will be re-rendered with updated prop.



```jsx

import { useNode } from "@craftjs/core";



const TextComponent = ({ text }) => {

  const {

    connectors: { connect, drag },

    isClicked,

    actions: { setProp },

  } = useNode((state) => ({

    isClicked: state.events.selected,

  }));



  return (

    
 connect(drag(dom))}>

      
{text}


      {isClicked ? (

        

           setProp(e.target.value)}

          />

        

      ) : null}

    


  );

};

```

With this, you could easily implement content editable text or drag-to-resize components, just as any modern page editor would have.



### User components with droppable regions

Let's say we need a "Container" component which users can drop into the editor. Additionally, we would also like them to be able to drag and drop other components into the Container.



In Craft.js, it's as simple as calling the ``



```jsx

import {useNode} from "@craftjs/core";

const Container = () => {

  const { connectors: {drag} } = useNode();



  return (

    


      

         // Now users will be able to drag/drop components into this section

        

      

    


  )

}

```



### Extensible

Craft.js provides an expressive API which allows you to easily read and manipulate the editor state. Let's say you would like to implement a copy function for a component:

```jsx

import {useEditor, useNode} from "@craftjs/core";

const Container = () => {

  const { actions: {add}, query: { createNode, node } } = useEditor();

  const { id, connectors: {drag, connect} } = useNode();

  return (

    
 connect(drag(dom))}>

      ...

       {

        const { data: {type, props}} = node(id).get();

        add(

          createNode(React.createElement(type, props));

        );

      }}>

        Make a copy of me

      

    


  )

}



```



### Serializable state

The editor's state can be serialized into JSON which you can then apply a compression technique of your choice for storage.



```jsx

const SaveButton = () => {

  const { query } = useEditor();

  return  console.log(query.serialize()) }>Get JSON

}

```



Of course, Craft.js will also able to recreate the entire state from the JSON string.

```jsx

const App = () => {

  const jsonString = /* retrieve JSON from server */

  return (

    

      

        ...

      

    

  )

}

```



## Who is this for? 🤔

You should use this if:

- ✅ You want to design your page editor according to your own UI specifications. With Craft.js, you control almost every aspect of the look and feel of your page editor.

- ✅ You like the React ecosystem. Being a React framework, not only do you get to build your user interface declaratively, but you will also be able to extend upon thousands of existing React components for your page editor.

- ✅ You're the coolest kid in class 😎



You should not use this if:

- ❌ You need a page editor that works out of the box. Craft.js is an abstraction where you implement your own page editor upon. For example, it does not come with a ready-made user interface.

  - However, you could still consider using the [examples](https://github.com/prevwong/craft.js/tree/develop/examples) as a starting point.



## Additional Packages :tada:

- **[@craftjs/layers](https://github.com/prevwong/craft.js/tree/develop/packages/layers)** A Photoshop-like layers panel



## Acknowledgements :raised_hands:



- **[react-dnd](https://github.com/react-dnd/react-dnd)** The React drag-n-drop library.

Although it is not actually used here, many aspects of Craft.js are written with react-dnd as a reference along with some utilities and functions being borrowed.

- **[Grape.js](https://github.com/artf/grapesjs)** The HTML web builder framework. This has served as an inspiration for Craft.js. The element positioning logic used in Craft.js is borrowed from Grape.js

- **[use-methods](https://github.com/pelotom/use-methods)** A super handy hook when dealing with reducers. Craft.js uses a slightly modified version of `use-methods` to better fit our API.



## Getting Help :wave:



If you have questions or there's something you'd like to discuss (eg: contributing), please head over to our [Discord](https://discord.gg/sPpF7fX) server.



## Sponsor :heart_decoration:



Craft.js is released under the [MIT license](https://github.com/prevwong/craft.js/blob/master/LICENSE) and is built with 100% love. If you found it useful and would like to ensure its continued development, please consider becoming a backer/sponsor or making a one-time donation via Github Sponsor, Open Collective or Ko-fi.








### Sponsors

- [Tangro](https://opencollective.com/tangro-software-components-gmbh)



### Backers

- [Tekeste Kidanu](https://opencollective.com/guest-1703f486)

- [CORS Digital](https://opencollective.com/cors-digital)

- [Mattermix](https://opencollective.com/mattermix)

- [muttenzer](https://github.com/muttenzer)

- [ITCuw](https://github.com/ITCuw)

- [quan](https://github.com/qu8n)

- [Victor Vanegas](vicvans20)

- [kasayo](https://opencollective.com/kasayo)