Download the PHP package shipfast/live-edit without Composer

On this page you can find all versions of the php package shipfast/live-edit. It is possible to download/install these versions without Composer. Possible dependencies are resolved automatically.

FAQ

After the download, you have to make one include require_once('vendor/autoload.php');. After that you have to import the classes with use statements.

Example:
If you use only one package a project is not needed. But if you use more then one package, without a project it is not possible to import the classes with use statements.

In general, it is recommended to use always a project to download your libraries. In an application normally there is more than one library needed.
Some PHP packages are not free to download and because of that hosted in private repositories. In this case some credentials are needed to access such packages. Please use the auth.json textarea to insert credentials, if a package is coming from a private repository. You can look here for more information.

  • Some hosting areas are not accessible by a terminal or SSH. Then it is not possible to use Composer.
  • To use Composer is sometimes complicated. Especially for beginners.
  • Composer needs much resources. Sometimes they are not available on a simple webspace.
  • If you are using private repositories you don't need to share your credentials. You can set up everything on our site and then you provide a simple download link to your team member.
  • Simplify your Composer build process. Use our own command line tool to download the vendor folder as binary. This makes your build process faster and you don't need to expose your credentials for private repositories.
Please rate this library. Is it a good library?

Informations about the package live-edit

ShipFast Live Edit

In-place editing for sites that are already built. Tag the elements, and the people who own the site edit text, images, links, icons, styles and lists on the page itself. There are no admin screens for content, because the page is the admin screen.

The inline SVG picker includes common outline icons, drawings already used by the site, and an option to paste a custom SVG. The bundled icon set is fetched only when someone opens that picker, so it adds no request to visitor page loads or to the editor's initial load.

It runs on five kinds of site, through adapters over one engine:

How it is installed
Laravel this package, tagging Blade views
WordPress a plugin, keeping content in the client's own database
Plain HTML one script tag
Next.js @shipfasts/live-edit-react, with a codemod
React the same package, provider and overlay

What has been driven through a browser on a real site is in ADAPTERS.md. What does not work yet is in LIMITATIONS.md.

The rest of this file is the Laravel adapter. The other adapters have their own instructions in the console when a site is registered.


Install

Two commands and one line.

Then in your layout's <head>:

That is the whole integration. Nothing to import, nothing to publish, nothing to add to your asset build.

Do not import the editor in app.js. Bundling it compiles a copy of the engine into your assets, so an engine fix only reaches you when you rebuild and redeploy. Until then the copy in your bundle and the one composer installed are different versions of the same thing, with nothing to say so. @liveEdit loads the installed package, so updating is composer update.

Who can edit

Define the live-edit gate:

Nobody else is served the editor at all, so a visitor's page is exactly the page they would have had without this package.

Sign-in is served for you at /live-edit/sign-in. Link to it wherever suits:

It authenticates against your users, with your guard and your password hashes. The package stores no credential and has no user of its own. All it needs is a users table and an auth provider, which a Laravel app has whether or not it has ever had a login screen.

Signing out is POST /live-edit/sign-out.

Making text editable

Two ways, and they mix.

Named keys, written by you. Stable: the key says what the element is for, so the client's words survive you rewriting the sentence around them. Worth writing for anything important.

Derived keys, found automatically. Set LIVE_EDIT_AUTO_TAG=true and the editable parts of a page are found as it is served, only for somebody the gate allows. The trade is that a derived key is a signature of the current wording: change that sentence in the template and the client's edit is orphaned. Use it to make a site editable without touching its templates, which is the only option for a site somebody bought rather than built.

A page that already carries data-edit keeps its own keys untouched.

Locking the parts a client must not change

New in 0.14.

You hand over a site with your name on it. A client will forgive a rough install. They will not forgive breaking the navigation, and neither will you.

Wrap anything they should not touch:

A nav, a footer, a pricing table, a legal line. In the markup rather than a dashboard, so it is reviewable in a pull request and cannot drift out of step with a setting somebody changed in a browser eight months ago.

Then define the live-edit-locked gate to say who is trusted with them:

Who What they get
Passes live-edit-locked everything, including locked parts
Fails it everything except the locked parts

Locked means fully refused, not just the text. Somebody narrowed cannot reword it, restyle it, or reorder the links inside it.

If you never define the gate, nothing is locked for anyone. An install that upgrades keeps working exactly as it did.

data-live-lock is not data-no-edit. They sound similar and do opposite jobs:

The three values a site is given

APP_KEY is public. It is printed into the source of every page it edits, so it is not a secret and its name should not suggest one.

A site whose content lives with the service needs LIVE_EDIT_APP_KEY in its own environment, not only in the page. Until 0.15.4 nothing on the server side ever asked the service anything, so an install could work without one: the key reaches the browser through the loader script the service generates, and the editor only ever ran in the browser. From 0.15.4 the server reads published content while rendering a page, so that it is in the HTML a visitor and a crawler get rather than swapped in afterwards, and that read needs the key.

Without it, nothing fails. The editor works, the browser swaps every change in, and the client sees their own site exactly as they left it; only visitors and search engines are served the words in your templates. From 0.15.8 the log says so once an hour instead of leaving you to find it.

A site whose own server talks to the service, to let its people in or to publish, also sets LIVE_EDIT_SECRET_KEY. A Laravel or WordPress install that keeps its own content never calls that API and never needs one.

Older names (LIVE_EDIT_SITE, LIVE_EDIT_KEY, and the LIVE_EDIT_LICENCE_* / LIVE_EDIT_CLOUD_* pairs) are all still read, so upgrading changes nothing on a running site. An install using a retired name says so in its log once a day.

Where content lives, and where people sign in

Two different questions. Forcing one answer onto every technology is what makes this kind of product awkward to install.

Integration Signing in Content lives
Laravel your own accounts your database
WordPress your own accounts your database
Static / React with us our cloud

Laravel and WordPress already have users, permissions and somewhere to put words, so we do not duplicate any of it. A static site has nothing to borrow, which is what the cloud content model is for.

Set LIVE_EDIT_SIGN_IN to host, service, or either (the default, and the only value that cannot lock somebody out of a site that worked yesterday). A host that defines the live-edit gate itself decides on its own and this is ignored.

Tagging an existing site

Point the scanner at a rendered page:

--apply is idempotent: re-running skips tagged nodes. Collections are reported but not auto-tagged, because they need a backing model and real ids that markup alone cannot supply. Always review the output. It is a draft.

Add --ai to turn the mechanical keys into semantic ones:

Set LIVE_EDIT_MAPPER_AI=true and OPENAI_API_KEY (override LIVE_EDIT_AI_ENDPOINT / LIVE_EDIT_AI_MODEL for a different model). The scanner still does all the detection. The model only renames and labels what it found, never adds or drops any, and any failure falls back to the deterministic result.

Configure

Everything editable is declared in config/live-edit.php:

The defaults work. Publish it when you want your own setting keys, models or locales.

Key What it does
setting_model the Eloquent model backing key/value settings
settings / images setting keys editable as text / as images
models collections (class, fields, creatable, deletable, ...)
style_props, icon_options, rich_fields typed field metadata
middleware guards the endpoints (default ['web', 'auth', 'can:live-edit'])
after_save runs after every write, e.g. to bust a cache

Optional page structure controls

Live Edit keeps the page structure unchanged unless the template opts in. To make existing sections reorderable, mark one region and every direct section inside it:

Section movement is available only when every direct element child has a unique data-edit-section key and is not inside a locked area. Duplicate a section only when its author adds data-edit-section-duplicate="true"; that marker is the author's confirmation that its IDs, scripts and relationships can safely be copied. Sections are hidden and restored with the existing visibility control. Repeated collections retain their add, delete and move controls, and new copies receive distinct editing keys and HTML IDs.

Keep at least one original item in the template markup as the seed design. An owner may remove every visible item; choosing Add item later copies that seed from the original markup. A list that the developer ships with no item or seed template has no structure to copy, so Live Edit cannot invent a fresh gallery card or navigation row for it.

Templates without data-edit-section-region take the existing scanner path; the scanner skips the optional section pass entirely for them.

A host that marks pages itself can write the result of that pass directly: data-edit-list and data-edit-list-kind="sections" on the region, and data-edit-item, data-edit-section, data-edit-section-label and data-edit-section-duplicate on each section. The hosted service does this for templates that ship a Component Kit, because their pages arrive already marked and are never scanned.

How many a list holds

A list can say how many items its design holds:

At the maximum, + Add another and Duplicate item are disabled, and the drawer says why ("This design holds 9. Replace one, or delete one to add another."). At the minimum, Delete this item is disabled. Without these attributes a list has no limit and keeps at least one item, as before.

An added item copies the item it was added from, unless that item is the list's odd one out: when its class appears once and the list has a usual class, the copy is made from the nearest item of the usual class. A gallery that opens with one large photo gets a normal tile, not a second large one.

Two lists that are one collection

A row of tabs and its panels are one collection drawn twice. Each names the other:

Moving, duplicating or deleting an item in either saves the same order for both, so a panel added is a tab added. Items are matched by their ids (data-edit-item), so both lists use the same ids in the same order. A copy is renamed as any copy is (<id>--<new id>), and so are its references into the partner, so the new tab's aria-controls points at the new panel. The browser and the server do this the same way.

Settings a card's words do not show

A filter should read a card's own words, so a card the owner adds or retypes is filtered by what it says. Where a card cannot say it (a gallery photo filed under "Exterior", a course under its start month), the card carries the category in an attribute, and the list declares it so the owner can choose it:

For each declared setting the item's panel shows a select of the filter's own choices, in its words and order, without its show-everything value or counts (value names the attribute on each control holding its value; value itself when absent, so radios and a select's options work as they are). "many": true shows boxes for an item in several (a space-separated list). A card's settings are saved together as one JSON object under its key and written onto the card on the page and when publishing, only to the attributes its list declares. A copy gets a key of its own (@<new id>), so it can be filed differently from its original.

The Shop tab

A host that serves a shop hands the editor its facts in one place (window.liveEditShop), each with the key it is saved under, and the drawer gains a Shop tab:

The fields are the words the pages already show, so changing one here changes the page, and anything that reads it (a bag's total) follows. A term written on several pages is one field saved to every key. A WhatsApp field edits the number inside the link and keeps the message after it.

Links the editor steers

A host that serves pages in its own editor can keep the visitor's address in href and put the editor's address for the same page in data-editor-href. Open this link in the drawer follows data-editor-href when present. The link field always shows and saves the href, so the address a customer publishes is never the editor's.

Help (the ? button)

Help is written for somebody who has never edited a website. It opens on what this kind of site is for and where to start, then offers:

The host says what kind of site it is:

kind is one of shop, school, university, training, salon, studio, restaurant, hotel, charity, worship, property or fintech. Otherwise the first two digits of category choose:

01 02 03 04 05 06 07 08 09 10 11
portfolio business services agency beauty school restaurant tech health charity shop

Without it, a site with a Shop tab is treated as a shop and anything else gets general help. The content is in resources/js/help.js.

The SEO tab

When the host sets window.liveEditSeo, the drawer has an SEO tab for the page being edited: its title, its search description and, when the host gives an imageKey, its share image (the picture a link to the page shows in a chat or a feed: og:image and twitter:image).

The share image is chosen with the editor's own picture chooser (upload, free photos, or generate with credits), previewed as a link card under the search preview, and saved as an address; "Use the design's own" saves it empty.

A card and its page

A product, a journal post, a project or a course is two things on a site: a card in a list and the detail page the card opens. The owner manages both from the card. The page is found from the card's link, by its address or, for the design's own pages, by the data-link-page the Kit gives it (pageOfLink in pages.js). Everything below is in card-page.js.

Edit all details: the page itself, edited in place

Picking a card offers Edit all details. It opens a window over the list holding the card's page as itself: the editor, loaded in a frame on that page in detail mode (?live-edit=detail, detailAddress). Only the record's own components are shown, with their layout, photos, options and words (showOnlyTheDetail, using the same component rule as before: linked-detail-scope.js). The header, menus, footer, related cards and sticky buy bars are hidden, not removed, so the template's own scripts keep working.

The owner edits by clicking the component, with the same panel, controls and saves as on the page: words, the picture chooser and upload, links, styles, list add, remove, duplicate and reorder (sizes, colours, a post's pictures), card settings. Saves are ordinary drafts, so they show under Changes, undo, and go live when the owner publishes from the bar. Each save in the frame tells the list (live-edit:detail-saved); closing the window reads the saved content again, so the list shows what was saved. Open the whole page → is still offered, but nothing requires it. Page-section controls (move, copy, hide a section) are left to the whole page, where the rest can be seen.

Nothing is generated: there is no form made from the page's fields. A new template feature works in this window as soon as its page component carries the ordinary editing attributes.

A copied card gets a full copy of its page

A card copied from another still opens the original's page. Before anything on it is edited, its panel offers Give it its own page, which makes a page that is a full copy of the one it shares, as it stands now, and opens it in the same window (copyPageForCard):

  1. The page. One section added for every section of the original, from the same design section, in the owner's order, out of the menu (structure:page:<id> with added, and an entry in structure:pages). A section the owner added to the original is copied from what it was added from, read from that page's own window.liveEditPages. The host draws each section with keys of its own (added:<page>/<added id>).
  2. Its lists. Every list's saved order, onto the copy's list keys, so the copy holds the same items (a size the owner added, one they deleted).
  3. Everything else. Both pages are read again and walked side by side: elements are matched by their position among same-tag siblings, which is how the host keys them, and list items by their id (keyMap). Every saved word, picture (with its description and credit), link, drawing, icon, card setting and style of the original is written under the copy's key (mappedKey, copiedSettings, copiedStyles).
  4. The card's own words. The name, photo, price and short description the owner saved on the card are written on the copy where they differ from the page (cardFacts, factTargets). What the card still shows from the design does not count, so a sample photo on the card never replaces the photo the owner chose for the page.

Then the card's link is pointed at the new page (hrefTo). The two pages share no key, so an edit to either never reaches the other. A copy is dozens of saves; a refusal for speed (429) is waited out rather than leaving a half copy.

Deleting a card deletes its page, if the owner says so

Delete this item on a card that opens a page no other card opens asks first: Delete the card and its page, Delete the card, keep its page, or Cancel. The question says what else still links to the page: links on this page (other cards, the menu) and links the owner pointed at it anywhere on the site (linksTo, linksWarning). Links the design wrote into other pages are not known to the editor.

Deleting a page is deletePage, an ordinary draft like any other change:

When adding a card or detail-page capability:

  1. Mark every field on the detail component with its normal Live Edit key; do not add a card-type-specific field mapping.
  2. Give the detail component its identity (.article, .detail, .products-pdp-title or .products-title on data-component, with its siblings sharing the instance prefix) so the window shows it and nothing else. Give option lists a human data-label ("Sizes", "Colours").
  3. Benchmark every template using it: a product with colours and sizes, a product with priced variants, and an article with long-form content. Open Edit all details, confirm related cards and sticky controls are hidden, change something, save, close and reopen. Then duplicate a card, give it its own page, confirm the copy carries every edit, edit both and confirm each stays itself. Delete a card with its page.
  4. Add a regression test for the markup shape before shipping (tests/js/a-card-and-its-page.test.js, tests/e2e/card-details-journey.spec.js).

The existing-template markup benchmark found 14 Oxbow-Hem product pages with repeatable colour and size lists, 16 Vellumair product pages with named and priced variants, and 45 blog/journal pages with an identified article component. Repeat it when the catalogue changes.

The Brand tab

When the host sets window.liveEditBrand before the editor loads, a Brand tab appears in the drawer and a Brand button in the toolbar. ?brand in the address opens the editor on it.

The page builder (New page)

When the host sets window.liveEditPages before the editor loads, a + New page button appears in the toolbar. It opens a window of two steps; ?pages in the address opens the editor on it. The host builds pages; the editor only says what the owner chose, as settings.

The drawer has two tabs, Edit and Changes (plus Brand and SEO where the host provides them). Changes holds both halves of what was saved: Not published yet and Published, switched just under the tabs.

Charts and tables

A library entry with a kind (bar, line, donut, funnel, progress, sparkline or table) is a chart or a table the host draws from its standard markup rather than cut from a page (at is null); the library says what each kind holds and the rules it keeps before it is added. On the page, a chart (data-chart) is edited in its kind's own terms (resources/js/data-kit.js, data-panel.js): a drawn bar, point or slice opens its row with the kind's fields and rules, the drawing opens the chart's settings (data-edit-choices with options named inline) and "Paste rows"; a table's cell (data-kit-table) opens with its row and column, each added, moved and deleted, every row kept in step by one saved order of columns. The host's contract is in the website's LIVE-EDIT-STRUCTURE.md, section 7, "Charts and tables the owner adds".

If something is wrong

Start here. One command, safe on production, that says where this site's published content is read from and whether that read works:

It names the four things that decide whether a visitor sees the client's words or the theme's: where content lives, whether tagging is on, whether the app key is set, and what the service actually answers. It never prints the key.

Making a picture takes credits and no picture comes. A picture is made in a queued job, so it needs a queue that is not sync and a worker running (php artisan queue:work). It also needs LIVE_EDIT_AI=true and OPENAI_API_KEY. The provider is given LIVE_EDIT_AI_IMAGE_JOB_TIMEOUT seconds (150 by default; two 1024px pictures often take over a minute) and the job 20 seconds more, so the queue connection's retry_after must be longer than that (over 170 by default), or the queue starts the job a second time. The credits are always given back when no picture is delivered: by the job when the provider fails, and, when the job never ran or died partway, the next time the editor asks about it, once its time is well past. The reason is kept in live_edit_image_generations.reason, and the provider's own words are in the log (storage/logs):

@liveEdit appears as text on the page. Blade prints a directive it does not know rather than erroring, so this ends up visible to visitors. The package is not registered:

The runtime loads but no toolbar appears. The editor mounts off the body, not the script tag. With LIVE_EDIT_AUTO_TAG=true that is done for you. Without it, your layout needs data-admin (and data-csrf) on <body> for whoever may edit.

Edits save, then vanish on reload. The save worked; nothing is putting the value back. With named keys your template renders it from your own model, so check that it does. With derived keys this is the middleware's job, so it means LIVE_EDIT_AUTO_TAG is off. If publishing is on, an unpublished change is deliberately only visible to an editor.

A client can still edit something you locked. The live-edit-locked gate is not defined, so nothing binds for anyone. See Locking the parts a client must not change.

Your own page tests started failing after upgrading to 0.15.4 or later. From 0.15.4 a site whose content lives with the service fetches it over HTTP while rendering a page, which earlier versions did not do. A suite that stubs its own api with a wildcard Http::fake(['*' => ...]) answers that call too, so the fixture arrives looking like published content and the page is rewritten with it; Http::preventStrayRequests() turns the same thing into a stray-request error. Neither is a fault in your suite.

Reading content off the machine is therefore off by default while the host application is running its tests, so an upgrade from 0.15.6 onwards needs nothing from you. A test that wants the real behaviour asks for it:

Set LIVE_EDIT_REMOTE_CONTENT=false to switch it off outside tests too. The page then renders the words in your templates, which is what it did before the package arrived.

What the package provides

Licence

Proprietary. Copyright (c) 2026 TryShipFast. See LICENSE.

The source is public so customers and integrators can read it, audit it and build against it. Readable is not the same as free to take: a current subscription lets you run it on sites you own or operate, including sites you build for clients, and does not let you redistribute it, resell it, or offer it as a service of your own.

If a subscription lapses, the editor stops. The websites do not. The content your clients wrote is in their own database and stays on their pages. Losing the licence means losing the editor, not the site.


All versions of live-edit with dependencies

PHP Build Version
Package Version
No informations.
Composer command for our command line client (download client) This client runs in each environment. You don't need a specific PHP version etc. The first 20 API calls are free. Standard composer command

The package shipfast/live-edit contains the following files

Loading the files please wait ...