adonisjs-livewire
Version:
A front-end framework for AdonisJS
1,555 lines (1,549 loc) • 323 kB
JavaScript
;(() => {
var __create = Object.create
var __defProp = Object.defineProperty
var __getOwnPropDesc = Object.getOwnPropertyDescriptor
var __getOwnPropNames = Object.getOwnPropertyNames
var __getProtoOf = Object.getPrototypeOf
var __hasOwnProp = Object.prototype.hasOwnProperty
var __commonJS = (cb, mod) =>
function __require() {
return (
mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports
)
}
var __copyProps = (to, from, except, desc) => {
if ((from && typeof from === 'object') || typeof from === 'function') {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, {
get: () => from[key],
enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable,
})
}
return to
}
var __toESM = (mod, isNodeMode, target) => (
(target = mod != null ? __create(__getProtoOf(mod)) : {}),
__copyProps(
isNodeMode || !mod || !mod.__esModule
? __defProp(target, 'default', { value: mod, enumerable: true })
: target,
mod
)
)
// node_modules/nprogress/nprogress.js
var require_nprogress = __commonJS({
'node_modules/nprogress/nprogress.js'(exports, module) {
;(function (root, factory) {
if (typeof define === 'function' && define.amd) {
define(factory)
} else if (typeof exports === 'object') {
module.exports = factory()
} else {
root.NProgress = factory()
}
})(exports, function () {
var NProgress2 = {}
NProgress2.version = '0.2.0'
var Settings = (NProgress2.settings = {
minimum: 0.08,
easing: 'ease',
positionUsing: '',
speed: 200,
trickle: true,
trickleRate: 0.02,
trickleSpeed: 800,
showSpinner: true,
barSelector: '[role="bar"]',
spinnerSelector: '[role="spinner"]',
parent: 'body',
template:
'<div class="bar" role="bar"><div class="peg"></div></div><div class="spinner" role="spinner"><div class="spinner-icon"></div></div>',
})
NProgress2.configure = function (options) {
var key
var value
for (key in options) {
value = options[key]
if (value !== void 0 && options.hasOwnProperty(key)) Settings[key] = value
}
return this
}
NProgress2.status = null
NProgress2.set = function (n) {
var started2 = NProgress2.isStarted()
n = clamp2(n, Settings.minimum, 1)
NProgress2.status = n === 1 ? null : n
var progress = NProgress2.render(!started2)
var bar = progress.querySelector(Settings.barSelector)
var speed = Settings.speed
var ease = Settings.easing
progress.offsetWidth
queue2(function (next) {
if (Settings.positionUsing === '')
Settings.positionUsing = NProgress2.getPositioningCSS()
css(bar, barPositionCSS(n, speed, ease))
if (n === 1) {
css(progress, {
transition: 'none',
opacity: 1,
})
progress.offsetWidth
setTimeout(function () {
css(progress, {
transition: 'all ' + speed + 'ms linear',
opacity: 0,
})
setTimeout(function () {
NProgress2.remove()
next()
}, speed)
}, speed)
} else {
setTimeout(next, speed)
}
})
return this
}
NProgress2.isStarted = function () {
return typeof NProgress2.status === 'number'
}
NProgress2.start = function () {
if (!NProgress2.status) NProgress2.set(0)
var work = function () {
setTimeout(function () {
if (!NProgress2.status) return
NProgress2.trickle()
work()
}, Settings.trickleSpeed)
}
if (Settings.trickle) work()
return this
}
NProgress2.done = function (force) {
if (!force && !NProgress2.status) return this
return NProgress2.inc(0.3 + 0.5 * Math.random()).set(1)
}
NProgress2.inc = function (amount) {
var n = NProgress2.status
if (!n) {
return NProgress2.start()
} else {
if (typeof amount !== 'number') {
amount = (1 - n) * clamp2(Math.random() * n, 0.1, 0.95)
}
n = clamp2(n + amount, 0, 0.994)
return NProgress2.set(n)
}
}
NProgress2.trickle = function () {
return NProgress2.inc(Math.random() * Settings.trickleRate)
}
;(function () {
var initial = 0
var current = 0
NProgress2.promise = function ($promise) {
if (!$promise || $promise.state() === 'resolved') {
return this
}
if (current === 0) {
NProgress2.start()
}
initial++
current++
$promise.always(function () {
current--
if (current === 0) {
initial = 0
NProgress2.done()
} else {
NProgress2.set((initial - current) / initial)
}
})
return this
}
})()
NProgress2.render = function (fromStart) {
if (NProgress2.isRendered()) return document.getElementById('nprogress')
addClass(document.documentElement, 'nprogress-busy')
var progress = document.createElement('div')
progress.id = 'nprogress'
progress.innerHTML = Settings.template
var bar = progress.querySelector(Settings.barSelector)
var perc = fromStart ? '-100' : toBarPerc(NProgress2.status || 0)
var parent = document.querySelector(Settings.parent)
var spinner
css(bar, {
transition: 'all 0 linear',
transform: 'translate3d(' + perc + '%,0,0)',
})
if (!Settings.showSpinner) {
spinner = progress.querySelector(Settings.spinnerSelector)
spinner && removeElement(spinner)
}
if (parent != document.body) {
addClass(parent, 'nprogress-custom-parent')
}
parent.appendChild(progress)
return progress
}
NProgress2.remove = function () {
removeClass(document.documentElement, 'nprogress-busy')
removeClass(document.querySelector(Settings.parent), 'nprogress-custom-parent')
var progress = document.getElementById('nprogress')
progress && removeElement(progress)
}
NProgress2.isRendered = function () {
return !!document.getElementById('nprogress')
}
NProgress2.getPositioningCSS = function () {
var bodyStyle = document.body.style
var vendorPrefix =
'WebkitTransform' in bodyStyle
? 'Webkit'
: 'MozTransform' in bodyStyle
? 'Moz'
: 'msTransform' in bodyStyle
? 'ms'
: 'OTransform' in bodyStyle
? 'O'
: ''
if (vendorPrefix + 'Perspective' in bodyStyle) {
return 'translate3d'
} else if (vendorPrefix + 'Transform' in bodyStyle) {
return 'translate'
} else {
return 'margin'
}
}
function clamp2(n, min2, max2) {
if (n < min2) return min2
if (n > max2) return max2
return n
}
function toBarPerc(n) {
return (-1 + n) * 100
}
function barPositionCSS(n, speed, ease) {
var barCSS
if (Settings.positionUsing === 'translate3d') {
barCSS = { transform: 'translate3d(' + toBarPerc(n) + '%,0,0)' }
} else if (Settings.positionUsing === 'translate') {
barCSS = { transform: 'translate(' + toBarPerc(n) + '%,0)' }
} else {
barCSS = { 'margin-left': toBarPerc(n) + '%' }
}
barCSS.transition = 'all ' + speed + 'ms ' + ease
return barCSS
}
var queue2 = (function () {
var pending = []
function next() {
var fn = pending.shift()
if (fn) {
fn(next)
}
}
return function (fn) {
pending.push(fn)
if (pending.length == 1) next()
}
})()
var css = (function () {
var cssPrefixes = ['Webkit', 'O', 'Moz', 'ms']
var cssProps = {}
function camelCase3(string) {
return string.replace(/^-ms-/, 'ms-').replace(/-([\da-z])/gi, function (match, letter) {
return letter.toUpperCase()
})
}
function getVendorProp(name) {
var style = document.body.style
if (name in style) return name
var i = cssPrefixes.length
var capName = name.charAt(0).toUpperCase() + name.slice(1)
var vendorName
while (i--) {
vendorName = cssPrefixes[i] + capName
if (vendorName in style) return vendorName
}
return name
}
function getStyleProp(name) {
name = camelCase3(name)
return cssProps[name] || (cssProps[name] = getVendorProp(name))
}
function applyCss(element, prop, value) {
prop = getStyleProp(prop)
element.style[prop] = value
}
return function (element, properties2) {
var args = arguments
var prop
var value
if (args.length == 2) {
for (prop in properties2) {
value = properties2[prop]
if (value !== void 0 && properties2.hasOwnProperty(prop))
applyCss(element, prop, value)
}
} else {
applyCss(element, args[1], args[2])
}
}
})()
function hasClass(element, name) {
var list = typeof element === 'string' ? element : classList(element)
return list.indexOf(' ' + name + ' ') >= 0
}
function addClass(element, name) {
var oldList = classList(element)
var newList = oldList + name
if (hasClass(oldList, name)) return
element.className = newList.substring(1)
}
function removeClass(element, name) {
var oldList = classList(element)
var newList
if (!hasClass(element, name)) return
newList = oldList.replace(' ' + name + ' ', ' ')
element.className = newList.substring(1, newList.length - 1)
}
function classList(element) {
return (' ' + (element.className || '') + ' ').replace(/\s+/gi, ' ')
}
function removeElement(element) {
element && element.parentNode && element.parentNode.removeChild(element)
}
return NProgress2
})
},
})
// js/utils.js
var WeakBag = class {
constructor() {
this.arrays = /* @__PURE__ */ new WeakMap()
}
add(key, value) {
if (!this.arrays.has(key)) this.arrays.set(key, [])
this.arrays.get(key).push(value)
}
get(key) {
return this.arrays.has(key) ? this.arrays.get(key) : []
}
each(key, callback) {
return this.get(key).forEach(callback)
}
}
function dispatch(el, name, detail = {}, bubbles = true) {
el.dispatchEvent(
new CustomEvent(name, {
detail,
bubbles,
composed: true,
cancelable: true,
})
)
}
function isObjecty(subject) {
return typeof subject === 'object' && subject !== null
}
function isObject(subject) {
return isObjecty(subject) && !isArray(subject)
}
function isArray(subject) {
return Array.isArray(subject)
}
function isFunction(subject) {
return typeof subject === 'function'
}
function isPrimitive(subject) {
return typeof subject !== 'object' || subject === null
}
function deepClone(obj) {
return JSON.parse(JSON.stringify(obj))
}
function dataGet(object, key) {
if (key === '') return object
return key.split('.').reduce((carry, i) => {
if (carry === void 0) return void 0
return carry[i]
}, object)
}
function dataSet(object, key, value) {
let segments = key.split('.')
if (segments.length === 1) {
return (object[key] = value)
}
let firstSegment = segments.shift()
let restOfSegments = segments.join('.')
if (object[firstSegment] === void 0) {
object[firstSegment] = {}
}
dataSet(object[firstSegment], restOfSegments, value)
}
function diff(left, right, diffs = {}, path = '') {
if (left === right) return diffs
if (
typeof left !== typeof right ||
(isObject(left) && isArray(right)) ||
(isArray(left) && isObject(right))
) {
diffs[path] = right
return diffs
}
if (isPrimitive(left) || isPrimitive(right)) {
diffs[path] = right
return diffs
}
let leftKeys = Object.keys(left)
Object.entries(right).forEach(([key, value]) => {
diffs = {
...diffs,
...diff(left[key], right[key], diffs, path === '' ? key : `${path}.${key}`),
}
leftKeys = leftKeys.filter((i) => i !== key)
})
leftKeys.forEach((key) => {
diffs[`${path}.${key}`] = '__rm__'
})
return diffs
}
function extractData(payload) {
let value = isSynthetic(payload) ? payload[0] : payload
let meta = isSynthetic(payload) ? payload[1] : void 0
if (isObjecty(value)) {
Object.entries(value).forEach(([key, iValue]) => {
value[key] = extractData(iValue)
})
}
return value
}
function isSynthetic(subject) {
return (
Array.isArray(subject) &&
subject.length === 2 &&
typeof subject[1] === 'object' &&
Object.keys(subject[1]).includes('s')
)
}
function getCsrfToken() {
if (document.querySelector('meta[name="csrf-token"]')) {
return document.querySelector('meta[name="csrf-token"]').getAttribute('content')
}
if (document.querySelector('[data-csrf]')) {
return document.querySelector('[data-csrf]').getAttribute('data-csrf')
}
if (window.livewireScriptConfig['csrf'] ?? false) {
return window.livewireScriptConfig['csrf']
}
throw 'Livewire: No CSRF token detected'
}
function getUpdateUri() {
return (
document.querySelector('[data-update-uri]')?.getAttribute('data-update-uri') ??
window.livewireScriptConfig['uri'] ??
null
)
}
function contentIsFromDump(content) {
return !!content.match(/<script>Sfdump\(".+"\)<\/script>/)
}
function splitDumpFromContent(content) {
let dump2 = content.match(/.*<script>Sfdump\(".+"\)<\/script>/s)
return [dump2, content.replace(dump2, '')]
}
// js/hooks.js
var listeners = []
function on(name, callback) {
if (!listeners[name]) listeners[name] = []
listeners[name].push(callback)
return () => {
listeners[name] = listeners[name].filter((i) => i !== callback)
}
}
function trigger(name, ...params) {
let callbacks = listeners[name] || []
let finishers = []
for (const callback of callbacks) {
let finisher = callback(...params)
if (isFunction(finisher)) finishers.push(finisher)
}
return (result) => {
return runFinishers(finishers, result)
}
}
async function triggerAsync(name, ...params) {
let callbacks = listeners[name] || []
let finishers = []
for (const callback of callbacks) {
let finisher = await callback(...params)
if (isFunction(finisher)) finishers.push(finisher)
}
return (result) => {
return runFinishers(finishers, result)
}
}
function runFinishers(finishers, result) {
let latest = result
for (const finisher of finishers) {
let iResult = finisher(latest)
if (iResult !== void 0) {
latest = iResult
}
}
return latest
}
// js/features/supportFileUploads.js
var uploadManagers = /* @__PURE__ */ new WeakMap()
function getUploadManager(component) {
if (!uploadManagers.has(component)) {
let manager = new UploadManager(component)
uploadManagers.set(component, manager)
manager.registerListeners()
}
return uploadManagers.get(component)
}
function handleFileUpload(el, property, component, cleanup3) {
let manager = getUploadManager(component)
let start3 = () =>
el.dispatchEvent(
new CustomEvent('livewire-upload-start', {
bubbles: true,
detail: { id: component.id, property },
})
)
let finish = () =>
el.dispatchEvent(
new CustomEvent('livewire-upload-finish', {
bubbles: true,
detail: { id: component.id, property },
})
)
let error2 = () =>
el.dispatchEvent(
new CustomEvent('livewire-upload-error', {
bubbles: true,
detail: { id: component.id, property },
})
)
let progress = (progressEvent) => {
var percentCompleted = Math.round((progressEvent.loaded * 100) / progressEvent.total)
el.dispatchEvent(
new CustomEvent('livewire-upload-progress', {
bubbles: true,
detail: { progress: percentCompleted },
})
)
}
let eventHandler = (e) => {
if (e.target.files.length === 0) return
start3()
if (e.target.multiple) {
manager.uploadMultiple(property, e.target.files, finish, error2, progress)
} else {
manager.upload(property, e.target.files[0], finish, error2, progress)
}
}
el.addEventListener('change', eventHandler)
let clearFileInputValue = () => {
el.value = null
}
el.addEventListener('click', clearFileInputValue)
cleanup3(() => {
el.removeEventListener('change', eventHandler)
el.removeEventListener('click', clearFileInputValue)
})
}
var UploadManager = class {
constructor(component) {
this.component = component
this.uploadBag = new MessageBag()
this.removeBag = new MessageBag()
}
registerListeners() {
this.component.$wire.$on('upload:generatedSignedUrl', ({ name, url }) => {
setUploadLoading(this.component, name)
this.handleSignedUrl(name, url)
})
this.component.$wire.$on('upload:generatedSignedUrlForS3', ({ name, payload }) => {
setUploadLoading(this.component, name)
this.handleS3PreSignedUrl(name, payload)
})
this.component.$wire.$on('upload:finished', ({ name, tmpFilenames }) =>
this.markUploadFinished(name, tmpFilenames)
)
this.component.$wire.$on('upload:errored', ({ name }) => this.markUploadErrored(name))
this.component.$wire.$on('upload:removed', ({ name, tmpFilename }) =>
this.removeBag.shift(name).finishCallback(tmpFilename)
)
}
upload(name, file, finishCallback, errorCallback, progressCallback) {
this.setUpload(name, {
files: [file],
multiple: false,
finishCallback,
errorCallback,
progressCallback,
})
}
uploadMultiple(name, files, finishCallback, errorCallback, progressCallback) {
this.setUpload(name, {
files: Array.from(files),
multiple: true,
finishCallback,
errorCallback,
progressCallback,
})
}
removeUpload(name, tmpFilename, finishCallback) {
this.removeBag.push(name, {
tmpFilename,
finishCallback,
})
this.component.$wire.call('_removeUpload', name, tmpFilename)
}
setUpload(name, uploadObject) {
this.uploadBag.add(name, uploadObject)
if (this.uploadBag.get(name).length === 1) {
this.startUpload(name, uploadObject)
}
}
handleSignedUrl(name, url) {
let formData = new FormData()
Array.from(this.uploadBag.first(name).files).forEach((file) =>
formData.append('files[]', file, file.name)
)
let headers = {
Accept: 'application/json',
}
let csrfToken = getCsrfToken()
if (csrfToken) headers['X-CSRF-TOKEN'] = csrfToken
this.makeRequest(name, formData, 'post', url, headers, (response) => {
return response.paths
})
}
handleS3PreSignedUrl(name, payload) {
let formData = this.uploadBag.first(name).files[0]
let headers = payload.headers
if ('Host' in headers) delete headers.Host
let url = payload.url
this.makeRequest(name, formData, 'put', url, headers, (response) => {
return [payload.path]
})
}
makeRequest(name, formData, method, url, headers, retrievePaths) {
let request = new XMLHttpRequest()
request.open(method, url)
Object.entries(headers).forEach(([key, value]) => {
request.setRequestHeader(key, value)
})
request.upload.addEventListener('progress', (e) => {
e.detail = {}
e.detail.progress = Math.round((e.loaded * 100) / e.total)
this.uploadBag.first(name).progressCallback(e)
})
request.addEventListener('load', () => {
if ((request.status + '')[0] === '2') {
let paths = retrievePaths(request.response && JSON.parse(request.response))
this.component.$wire.call(
'_finishUpload',
name,
paths,
this.uploadBag.first(name).multiple
)
return
}
let errors = null
if (request.status === 422) {
errors = request.response
}
this.component.$wire.call(
'_uploadErrored',
name,
errors,
this.uploadBag.first(name).multiple
)
})
request.send(formData)
}
startUpload(name, uploadObject) {
let fileInfos = uploadObject.files.map((file) => {
return { name: file.name, size: file.size, type: file.type }
})
this.component.$wire.call('_startUpload', name, fileInfos, uploadObject.multiple)
setUploadLoading(this.component, name)
}
markUploadFinished(name, tmpFilenames) {
unsetUploadLoading(this.component)
let uploadObject = this.uploadBag.shift(name)
uploadObject.finishCallback(uploadObject.multiple ? tmpFilenames : tmpFilenames[0])
if (this.uploadBag.get(name).length > 0) this.startUpload(name, this.uploadBag.last(name))
}
markUploadErrored(name) {
unsetUploadLoading(this.component)
this.uploadBag.shift(name).errorCallback()
if (this.uploadBag.get(name).length > 0) this.startUpload(name, this.uploadBag.last(name))
}
}
var MessageBag = class {
constructor() {
this.bag = {}
}
add(name, thing) {
if (!this.bag[name]) {
this.bag[name] = []
}
this.bag[name].push(thing)
}
push(name, thing) {
this.add(name, thing)
}
first(name) {
if (!this.bag[name]) return null
return this.bag[name][0]
}
last(name) {
return this.bag[name].slice(-1)[0]
}
get(name) {
return this.bag[name]
}
shift(name) {
return this.bag[name].shift()
}
call(name, ...params) {
;(this.listeners[name] || []).forEach((callback) => {
callback(...params)
})
}
has(name) {
return Object.keys(this.listeners).includes(name)
}
}
function setUploadLoading() {}
function unsetUploadLoading() {}
function upload(
component,
name,
file,
finishCallback = () => {},
errorCallback = () => {},
progressCallback = () => {}
) {
let uploadManager = getUploadManager(component)
uploadManager.upload(name, file, finishCallback, errorCallback, progressCallback)
}
function uploadMultiple(
component,
name,
files,
finishCallback = () => {},
errorCallback = () => {},
progressCallback = () => {}
) {
let uploadManager = getUploadManager(component)
uploadManager.uploadMultiple(name, files, finishCallback, errorCallback, progressCallback)
}
function removeUpload(
component,
name,
tmpFilename,
finishCallback = () => {},
errorCallback = () => {}
) {
let uploadManager = getUploadManager(component)
uploadManager.removeUpload(name, tmpFilename, finishCallback, errorCallback)
}
// ../alpine/packages/alpinejs/dist/module.esm.js
var flushPending = false
var flushing = false
var queue = []
var lastFlushedIndex = -1
function scheduler(callback) {
queueJob(callback)
}
function queueJob(job) {
if (!queue.includes(job)) queue.push(job)
queueFlush()
}
function dequeueJob(job) {
let index = queue.indexOf(job)
if (index !== -1 && index > lastFlushedIndex) queue.splice(index, 1)
}
function queueFlush() {
if (!flushing && !flushPending) {
flushPending = true
queueMicrotask(flushJobs)
}
}
function flushJobs() {
flushPending = false
flushing = true
for (const [i, element] of queue.entries()) {
element()
lastFlushedIndex = i
}
queue.length = 0
lastFlushedIndex = -1
flushing = false
}
var reactive
var effect
var release
var raw
var shouldSchedule = true
function disableEffectScheduling(callback) {
shouldSchedule = false
callback()
shouldSchedule = true
}
function setReactivityEngine(engine) {
reactive = engine.reactive
release = engine.release
effect = (callback) =>
engine.effect(callback, {
scheduler: (task) => {
if (shouldSchedule) {
scheduler(task)
} else {
task()
}
},
})
raw = engine.raw
}
function overrideEffect(override) {
effect = override
}
function elementBoundEffect(el) {
let cleanup22 = () => {}
let wrappedEffect = (callback) => {
let effectReference = effect(callback)
if (!el._x_effects) {
el._x_effects = /* @__PURE__ */ new Set()
el._x_runEffects = () => {
el._x_effects.forEach((i) => i())
}
}
el._x_effects.add(effectReference)
cleanup22 = () => {
if (effectReference === void 0) return
el._x_effects.delete(effectReference)
release(effectReference)
}
return effectReference
}
return [
wrappedEffect,
() => {
cleanup22()
},
]
}
function watch(getter, callback) {
let firstTime = true
let oldValue
let effectReference = effect(() => {
let value = getter()
JSON.stringify(value)
if (!firstTime) {
queueMicrotask(() => {
callback(value, oldValue)
oldValue = value
})
} else {
oldValue = value
}
firstTime = false
})
return () => release(effectReference)
}
function dispatch2(el, name, detail = {}) {
el.dispatchEvent(
new CustomEvent(name, {
detail,
bubbles: true,
composed: true,
cancelable: true,
})
)
}
function walk(el, callback) {
if (typeof ShadowRoot === 'function' && el instanceof ShadowRoot) {
Array.from(el.children).forEach((el2) => walk(el2, callback))
return
}
let skip = false
callback(el, () => (skip = true))
if (skip) return
let node = el.firstElementChild
while (node) {
walk(node, callback, false)
node = node.nextElementSibling
}
}
function warn(message, ...args) {
console.warn(`Alpine Warning: ${message}`, ...args)
}
var started = false
function start() {
if (started)
warn(
'Alpine has already been initialized on this page. Calling Alpine.start() more than once can cause problems.'
)
started = true
if (!document.body)
warn(
"Unable to initialize. Trying to load Alpine before `<body>` is available. Did you forget to add `defer` in Alpine's `<script>` tag?"
)
dispatch2(document, 'alpine:init')
dispatch2(document, 'alpine:initializing')
startObservingMutations()
onElAdded((el) => initTree(el, walk))
onElRemoved((el) => destroyTree(el))
onAttributesAdded((el, attrs) => {
directives(el, attrs).forEach((handle) => handle())
})
let outNestedComponents = (el) => !closestRoot(el.parentElement, true)
Array.from(document.querySelectorAll(allSelectors().join(',')))
.filter(outNestedComponents)
.forEach((el) => {
initTree(el)
})
dispatch2(document, 'alpine:initialized')
}
var rootSelectorCallbacks = []
var initSelectorCallbacks = []
function rootSelectors() {
return rootSelectorCallbacks.map((fn) => fn())
}
function allSelectors() {
return rootSelectorCallbacks.concat(initSelectorCallbacks).map((fn) => fn())
}
function addRootSelector(selectorCallback) {
rootSelectorCallbacks.push(selectorCallback)
}
function addInitSelector(selectorCallback) {
initSelectorCallbacks.push(selectorCallback)
}
function closestRoot(el, includeInitSelectors = false) {
return findClosest(el, (element) => {
const selectors = includeInitSelectors ? allSelectors() : rootSelectors()
if (selectors.some((selector) => element.matches(selector))) return true
})
}
function findClosest(el, callback) {
if (!el) return
if (callback(el)) return el
if (el._x_teleportBack) el = el._x_teleportBack
if (!el.parentElement) return
return findClosest(el.parentElement, callback)
}
function isRoot(el) {
return rootSelectors().some((selector) => el.matches(selector))
}
var initInterceptors = []
function interceptInit(callback) {
initInterceptors.push(callback)
}
function initTree(el, walker = walk, intercept = () => {}) {
deferHandlingDirectives(() => {
walker(el, (el2, skip) => {
intercept(el2, skip)
initInterceptors.forEach((i) => i(el2, skip))
directives(el2, el2.attributes).forEach((handle) => handle())
el2._x_ignore && skip()
})
})
}
function destroyTree(root) {
walk(root, (el) => {
cleanupAttributes(el)
cleanupElement(el)
})
}
var onAttributeAddeds = []
var onElRemoveds = []
var onElAddeds = []
function onElAdded(callback) {
onElAddeds.push(callback)
}
function onElRemoved(el, callback) {
if (typeof callback === 'function') {
if (!el._x_cleanups) el._x_cleanups = []
el._x_cleanups.push(callback)
} else {
callback = el
onElRemoveds.push(callback)
}
}
function onAttributesAdded(callback) {
onAttributeAddeds.push(callback)
}
function onAttributeRemoved(el, name, callback) {
if (!el._x_attributeCleanups) el._x_attributeCleanups = {}
if (!el._x_attributeCleanups[name]) el._x_attributeCleanups[name] = []
el._x_attributeCleanups[name].push(callback)
}
function cleanupAttributes(el, names) {
if (!el._x_attributeCleanups) return
Object.entries(el._x_attributeCleanups).forEach(([name, value]) => {
if (names === void 0 || names.includes(name)) {
value.forEach((i) => i())
delete el._x_attributeCleanups[name]
}
})
}
function cleanupElement(el) {
if (el._x_cleanups) {
while (el._x_cleanups.length) el._x_cleanups.pop()()
}
}
var observer = new MutationObserver(onMutate)
var currentlyObserving = false
function startObservingMutations() {
observer.observe(document, {
subtree: true,
childList: true,
attributes: true,
attributeOldValue: true,
})
currentlyObserving = true
}
function stopObservingMutations() {
flushObserver()
observer.disconnect()
currentlyObserving = false
}
var queuedMutations = []
function flushObserver() {
let records = observer.takeRecords()
queuedMutations.push(() => records.length > 0 && onMutate(records))
let queueLengthWhenTriggered = queuedMutations.length
queueMicrotask(() => {
if (queuedMutations.length === queueLengthWhenTriggered) {
while (queuedMutations.length > 0) queuedMutations.shift()()
}
})
}
function mutateDom(callback) {
if (!currentlyObserving) return callback()
stopObservingMutations()
let result = callback()
startObservingMutations()
return result
}
var isCollecting = false
var deferredMutations = []
function deferMutations() {
isCollecting = true
}
function flushAndStopDeferringMutations() {
isCollecting = false
onMutate(deferredMutations)
deferredMutations = []
}
function onMutate(mutations) {
if (isCollecting) {
deferredMutations = deferredMutations.concat(mutations)
return
}
let addedNodes = []
let removedNodes = []
let addedAttributes = /* @__PURE__ */ new Map()
let removedAttributes = /* @__PURE__ */ new Map()
for (const mutation of mutations) {
if (mutation.target._x_ignoreMutationObserver) continue
if (mutation.type === 'childList') {
mutation.addedNodes.forEach((node) => node.nodeType === 1 && addedNodes.push(node))
mutation.removedNodes.forEach((node) => node.nodeType === 1 && removedNodes.push(node))
}
if (mutation.type === 'attributes') {
let el = mutation.target
let name = mutation.attributeName
let oldValue = mutation.oldValue
let add2 = () => {
if (!addedAttributes.has(el)) addedAttributes.set(el, [])
addedAttributes.get(el).push({ name, value: el.getAttribute(name) })
}
let remove = () => {
if (!removedAttributes.has(el)) removedAttributes.set(el, [])
removedAttributes.get(el).push(name)
}
if (el.hasAttribute(name) && oldValue === null) {
add2()
} else if (el.hasAttribute(name)) {
remove()
add2()
} else {
remove()
}
}
}
removedAttributes.forEach((attrs, el) => {
cleanupAttributes(el, attrs)
})
addedAttributes.forEach((attrs, el) => {
onAttributeAddeds.forEach((i) => i(el, attrs))
})
for (let node of removedNodes) {
if (addedNodes.includes(node)) continue
onElRemoveds.forEach((i) => i(node))
destroyTree(node)
}
addedNodes.forEach((node) => {
node._x_ignoreSelf = true
node._x_ignore = true
})
for (let node of addedNodes) {
if (removedNodes.includes(node)) continue
if (!node.isConnected) continue
delete node._x_ignoreSelf
delete node._x_ignore
onElAddeds.forEach((i) => i(node))
node._x_ignore = true
node._x_ignoreSelf = true
}
addedNodes.forEach((node) => {
delete node._x_ignoreSelf
delete node._x_ignore
})
addedNodes = null
removedNodes = null
addedAttributes = null
removedAttributes = null
}
function scope(node) {
return mergeProxies(closestDataStack(node))
}
function addScopeToNode(node, data2, referenceNode) {
node._x_dataStack = [data2, ...closestDataStack(referenceNode || node)]
return () => {
node._x_dataStack = node._x_dataStack.filter((i) => i !== data2)
}
}
function closestDataStack(node) {
if (node._x_dataStack) return node._x_dataStack
if (typeof ShadowRoot === 'function' && node instanceof ShadowRoot) {
return closestDataStack(node.host)
}
if (!node.parentNode) {
return []
}
return closestDataStack(node.parentNode)
}
function mergeProxies(objects) {
return new Proxy({ objects }, mergeProxyTrap)
}
var mergeProxyTrap = {
ownKeys({ objects }) {
return Array.from(new Set(objects.flatMap((i) => Object.keys(i))))
},
has({ objects }, name) {
if (name == Symbol.unscopables) return false
return objects.some((obj) => Object.prototype.hasOwnProperty.call(obj, name))
},
get({ objects }, name, thisProxy) {
if (name == 'toJSON') return collapseProxies
return Reflect.get(
objects.find((obj) => Object.prototype.hasOwnProperty.call(obj, name)) || {},
name,
thisProxy
)
},
set({ objects }, name, value, thisProxy) {
const target =
objects.find((obj) => Object.prototype.hasOwnProperty.call(obj, name)) ||
objects[objects.length - 1]
const descriptor = Object.getOwnPropertyDescriptor(target, name)
if (descriptor?.set && descriptor?.get) return Reflect.set(target, name, value, thisProxy)
return Reflect.set(target, name, value)
},
}
function collapseProxies() {
let keys = Reflect.ownKeys(this)
return keys.reduce((acc, key) => {
acc[key] = Reflect.get(this, key)
return acc
}, {})
}
function initInterceptors2(data2) {
let isObject22 = (val) => typeof val === 'object' && !Array.isArray(val) && val !== null
let recurse = (obj, basePath = '') => {
Object.entries(Object.getOwnPropertyDescriptors(obj)).forEach(
([key, { value, enumerable }]) => {
if (enumerable === false || value === void 0) return
let path = basePath === '' ? key : `${basePath}.${key}`
if (typeof value === 'object' && value !== null && value._x_interceptor) {
obj[key] = value.initialize(data2, path, key)
} else {
if (isObject22(value) && value !== obj && !(value instanceof Element)) {
recurse(value, path)
}
}
}
)
}
return recurse(data2)
}
function interceptor(callback, mutateObj = () => {}) {
let obj = {
initialValue: void 0,
_x_interceptor: true,
initialize(data2, path, key) {
return callback(
this.initialValue,
() => get(data2, path),
(value) => set(data2, path, value),
path,
key
)
},
}
mutateObj(obj)
return (initialValue) => {
if (
typeof initialValue === 'object' &&
initialValue !== null &&
initialValue._x_interceptor
) {
let initialize = obj.initialize.bind(obj)
obj.initialize = (data2, path, key) => {
let innerValue = initialValue.initialize(data2, path, key)
obj.initialValue = innerValue
return initialize(data2, path, key)
}
} else {
obj.initialValue = initialValue
}
return obj
}
}
function get(obj, path) {
return path.split('.').reduce((carry, segment) => carry[segment], obj)
}
function set(obj, path, value) {
if (typeof path === 'string') path = path.split('.')
if (path.length === 1) obj[path[0]] = value
else if (path.length === 0) throw error
else {
if (obj[path[0]]) return set(obj[path[0]], path.slice(1), value)
else {
obj[path[0]] = {}
return set(obj[path[0]], path.slice(1), value)
}
}
}
var magics = {}
function magic(name, callback) {
magics[name] = callback
}
function injectMagics(obj, el) {
Object.entries(magics).forEach(([name, callback]) => {
let memoizedUtilities = null
function getUtilities() {
if (memoizedUtilities) {
return memoizedUtilities
} else {
let [utilities, cleanup22] = getElementBoundUtilities(el)
memoizedUtilities = { interceptor, ...utilities }
onElRemoved(el, cleanup22)
return memoizedUtilities
}
}
Object.defineProperty(obj, `$${name}`, {
get() {
return callback(el, getUtilities())
},
enumerable: false,
})
})
return obj
}
function tryCatch(el, expression, callback, ...args) {
try {
return callback(...args)
} catch (e) {
handleError(e, el, expression)
}
}
function handleError(error2, el, expression = void 0) {
Object.assign(error2, { el, expression })
console.warn(
`Alpine Expression Error: ${error2.message}
${expression ? 'Expression: "' + expression + '"\n\n' : ''}`,
el
)
setTimeout(() => {
throw error2
}, 0)
}
var shouldAutoEvaluateFunctions = true
function dontAutoEvaluateFunctions(callback) {
let cache = shouldAutoEvaluateFunctions
shouldAutoEvaluateFunctions = false
let result = callback()
shouldAutoEvaluateFunctions = cache
return result
}
function evaluate(el, expression, extras = {}) {
let result
evaluateLater(el, expression)((value) => (result = value), extras)
return result
}
function evaluateLater(...args) {
return theEvaluatorFunction(...args)
}
var theEvaluatorFunction = normalEvaluator
function setEvaluator(newEvaluator) {
theEvaluatorFunction = newEvaluator
}
function normalEvaluator(el, expression) {
let overriddenMagics = {}
injectMagics(overriddenMagics, el)
let dataStack = [overriddenMagics, ...closestDataStack(el)]
let evaluator =
typeof expression === 'function'
? generateEvaluatorFromFunction(dataStack, expression)
: generateEvaluatorFromString(dataStack, expression, el)
return tryCatch.bind(null, el, expression, evaluator)
}
function generateEvaluatorFromFunction(dataStack, func) {
return (receiver = () => {}, { scope: scope2 = {}, params = [] } = {}) => {
let result = func.apply(mergeProxies([scope2, ...dataStack]), params)
runIfTypeOfFunction(receiver, result)
}
}
var evaluatorMemo = {}
function generateFunctionFromString(expression, el) {
if (evaluatorMemo[expression]) {
return evaluatorMemo[expression]
}
let AsyncFunction = Object.getPrototypeOf(async function () {}).constructor
let rightSideSafeExpression =
/^[\n\s]*if.*\(.*\)/.test(expression.trim()) || /^(let|const)\s/.test(expression.trim())
? `(async()=>{ ${expression} })()`
: expression
const safeAsyncFunction = () => {
try {
let func2 = new AsyncFunction(
['__self', 'scope'],
`with (scope) { __self.result = ${rightSideSafeExpression} }; __self.finished = true; return __self.result;`
)
Object.defineProperty(func2, 'name', {
value: `[Alpine] ${expression}`,
})
return func2
} catch (error2) {
handleError(error2, el, expression)
return Promise.resolve()
}
}
let func = safeAsyncFunction()
evaluatorMemo[expression] = func
return func
}
function generateEvaluatorFromString(dataStack, expression, el) {
let func = generateFunctionFromString(expression, el)
return (receiver = () => {}, { scope: scope2 = {}, params = [] } = {}) => {
func.result = void 0
func.finished = false
let completeScope = mergeProxies([scope2, ...dataStack])
if (typeof func === 'function') {
let promise = func(func, completeScope).catch((error2) =>
handleError(error2, el, expression)
)
if (func.finished) {
runIfTypeOfFunction(receiver, func.result, completeScope, params, el)
func.result = void 0
} else {
promise
.then((result) => {
runIfTypeOfFunction(receiver, result, completeScope, params, el)
})
.catch((error2) => handleError(error2, el, expression))
.finally(() => (func.result = void 0))
}
}
}
}
function runIfTypeOfFunction(receiver, value, scope2, params, el) {
if (shouldAutoEvaluateFunctions && typeof value === 'function') {
let result = value.apply(scope2, params)
if (result instanceof Promise) {
result
.then((i) => runIfTypeOfFunction(receiver, i, scope2, params))
.catch((error2) => handleError(error2, el, value))
} else {
receiver(result)
}
} else if (typeof value === 'object' && value instanceof Promise) {
value.then((i) => receiver(i))
} else {
receiver(value)
}
}
var prefixAsString = 'x-'
function prefix(subject = '') {
return prefixAsString + subject
}
function setPrefix(newPrefix) {
prefixAsString = newPrefix
}
var directiveHandlers = {}
function directive(name, callback) {
directiveHandlers[name] = callback
return {
before(directive22) {
if (!directiveHandlers[directive22]) {
console.warn(
'Cannot find directive `${directive}`. `${name}` will use the default order of execution'
)
return
}
const pos = directiveOrder.indexOf(directive22)
directiveOrder.splice(pos >= 0 ? pos : directiveOrder.indexOf('DEFAULT'), 0, name)
},
}
}
function directives(el, attributes, originalAttributeOverride) {
attributes = Array.from(attributes)
if (el._x_virtualDirectives) {
let vAttributes = Object.entries(el._x_virtualDirectives).map(([name, value]) => ({
name,
value,
}))
let staticAttributes = attributesOnly(vAttributes)
vAttributes = vAttributes.map((attribute) => {
if (staticAttributes.find((attr) => attr.name === attribute.name)) {
return {
name: `x-bind:${attribute.name}`,
value: `"${attribute.value}"`,
}
}
return attribute
})
attributes = attributes.concat(vAttributes)
}
let transformedAttributeMap = {}
let directives2 = attributes
.map(
toTransformedAttributes((newName, oldName) => (transformedAttributeMap[newName] = oldName))
)
.filter(outNonAlpineAttributes)
.map(toParsedDirectives(transformedAttributeMap, originalAttributeOverride))
.sort(byPriority)
return directives2.map((directive22) => {
return getDirectiveHandler(el, directive22)
})
}
function attributesOnly(attributes) {
return Array.from(attributes)
.map(toTransformedAttributes())
.filter((attr) => !outNonAlpineAttributes(attr))
}
var isDeferringHandlers = false
var directiveHandlerStacks = /* @__PURE__ */ new Map()
var currentHandlerStackKey = Symbol()
function deferHandlingDirectives(callback) {
isDeferringHandlers = true
let key = Symbol()
currentHandlerStackKey = key
directiveHandlerStacks.set(key, [])
let flushHandlers = () => {
while (directiveHandlerStacks.get(key).length) directiveHandlerStacks.get(key).shift()()
directiveHandlerStacks.delete(key)
}
let stopDeferring = () => {
isDeferringHandlers = false
flushHandlers()
}
callback(flushHandlers)
stopDeferring()
}
function getElementBoundUtilities(el) {
let cleanups = []
let cleanup22 = (callback) => cleanups.push(callback)
let [effect3, cleanupEffect] = elementBoundEffect(el)
cleanups.push(cleanupEffect)
let utilities = {
Alpine: alpine_default,
effect: effect3,
cleanup: cleanup22,
evaluateLater: evaluateLater.bind(evaluateLater, el),
evaluate: evaluate.bind(evaluate, el),
}
let doCleanup = () => cleanups.forEach((i) => i())
return [utilities, doCleanup]
}
function getDirectiveHandler(el, directive22) {
let noop = () => {}
let handler4 = directiveHandlers[directive22.type] || noop
let [utilities, cleanup22] = getElementBoundUtilities(el)
onAttributeRemoved(el, directive22.original, cleanup22)
let fullHandler = () => {
if (el._x_ignore || el._x_ignoreSelf) return
handler4.inline && handler4.inline(el, directive22, utilities)
handler4 = handler4.bind(handler4, el, directive22, utilities)
isDeferringHandlers
? directiveHandlerStacks.get(currentHandlerStackKey).push(handler4)
: handler4()
}
fullHandler.runCleanups = cleanup22
return fullHandler
}
var startingWith =
(subject, replacement) =>
({ name, value }) => {
if (name.startsWith(subject)) name = name.replace(subject, replacement)
return { name, value }
}
var into = (i) => i
function toTransformedAttributes(callback = () => {}) {
return ({ name, value }) => {
let { name: newName, value: newValue } = attributeTransformers.reduce(
(carry, transform) => {
return transform(carry)
},
{ name, value }
)
if (newName !== name) callback(newName, name)
return { name: newName, value: newValue }
}
}
var attributeTransformers = []
function mapAttributes(callback) {
attributeTransformers.push(callback)
}
function outNonAlpineAttributes({ name }) {
return alpineAttributeRegex().test(name)
}
var alpineAttributeRegex = () => new RegExp(`^${prefixAsString}([^:^.]+)\\b`)
function toParsedDirectives(transformedAttributeMap, originalAttributeOverride) {
return ({ name, value }) => {
let typeMatch = name.match(alpineAttributeRegex())
let valueMatch = name.match(/:([a-zA-Z0-9\-_:]+)/)
let modifiers = name.match(/\.[^.\]]+(?=[^\]]*$)/g) || []
let original = originalAttributeOverride || transformedAttributeMap[name] || name
return {
type: typeMatch ? typeMatch[1] : null,
value: valueMatch ? valueMatch[1] : null,
modifiers: modifiers.map((i) => i.replace('.', '')),
expression: value,
original,
}
}
}
var DEFAULT = 'DEFAULT'
var directiveOrder = [
'ignore',
'ref',
'data',
'id',
'anchor',
'bind',
'init',
'for',
'model',
'mo