|
import React, { createContext } from "react"
|
|
|
|
import { sanitise } from "~/functions/sanitise"
|
|
import { smarts } from "~/smarts"
|
|
|
|
export interface ThingtimeContextInterface {
|
|
thingtime: any
|
|
setThingtime: any
|
|
getThingtime: any
|
|
thingtimeRef: any
|
|
}
|
|
|
|
export const ThingtimeContext = createContext<
|
|
ThingtimeContextInterface[] | null
|
|
>(null)
|
|
|
|
try {
|
|
window.smarts = smarts
|
|
} catch (err) {
|
|
// nothing
|
|
}
|
|
|
|
const forceable = {
|
|
Content: {
|
|
hidden1: "Edit this to your heart's desire.",
|
|
"How?": "Just search for Content and edit the value to whatever you want.",
|
|
"Example:": `Content = New Content!
|
|
Content.Nested Content = New Nested Content!
|
|
`,
|
|
},
|
|
}
|
|
|
|
const initialThingtime = {
|
|
nav: {},
|
|
version: 22,
|
|
...forceable,
|
|
}
|
|
|
|
const userData = {
|
|
settings: {
|
|
showCommander: true,
|
|
clearCommanderOnToggle: true,
|
|
clearCommanderContextOnToggle: true,
|
|
},
|
|
...forceable,
|
|
}
|
|
|
|
export const ThingtimeProvider = (props: any): JSX.Element => {
|
|
const [thingtime, set] = React.useState({
|
|
...initialThingtime,
|
|
...userData,
|
|
})
|
|
|
|
const thingtimeRef = React.useRef(thingtime)
|
|
|
|
// get thingtime from localstorage
|
|
React.useEffect(() => {
|
|
try {
|
|
const thingtimeFromLocalStorage = window.localStorage.getItem("thingtime")
|
|
|
|
if (thingtimeFromLocalStorage) {
|
|
const parsed = JSON.parse(thingtimeFromLocalStorage)
|
|
if (parsed) {
|
|
const invalidLocalStorage =
|
|
!parsed.version || parsed.version < initialThingtime.version
|
|
if (!invalidLocalStorage) {
|
|
set(parsed)
|
|
} else {
|
|
const newThingtime = {
|
|
...parsed,
|
|
...initialThingtime,
|
|
}
|
|
set(newThingtime)
|
|
}
|
|
}
|
|
}
|
|
} catch (err) {
|
|
console.error("There was an error getting thingtime from localStorage")
|
|
}
|
|
}, [])
|
|
|
|
React.useEffect(() => {
|
|
thingtimeRef.current = thingtime
|
|
|
|
try {
|
|
window.localStorage.setItem("thingtime", JSON.stringify(thingtime))
|
|
} catch (err) {
|
|
console.error("There was an error saving thingtime to localStorage")
|
|
}
|
|
}, [thingtime])
|
|
|
|
const setThingtime = React.useCallback(
|
|
(path, value) => {
|
|
const prevThingtime = thingtime
|
|
|
|
const newThingtime = {
|
|
...prevThingtime,
|
|
}
|
|
|
|
// check if first characters of path starts with thingtime or tt and strip from path
|
|
|
|
path = sanitise(path)
|
|
|
|
smarts.setsmart(newThingtime, path, value)
|
|
|
|
// subtract last path part from dot delimitted path
|
|
// prop1.prop2.prop3 => prop1.prop2
|
|
const pathParts = path.split(".")
|
|
pathParts.pop()
|
|
const parentPath = pathParts.join(".")
|
|
|
|
if (parentPath?.length) {
|
|
const parent = smarts.getsmart(newThingtime, parentPath)
|
|
|
|
const newParent = Array.isArray(parent) ? [...parent] : { ...parent }
|
|
|
|
smarts.setsmart(newThingtime, parentPath, newParent)
|
|
}
|
|
|
|
set(newThingtime)
|
|
},
|
|
[thingtime]
|
|
)
|
|
|
|
const getThingtime = React.useCallback(
|
|
(...args) => {
|
|
const rawPath = args[0]
|
|
if (
|
|
rawPath === "thingtime" ||
|
|
rawPath === "tt" ||
|
|
rawPath === "." ||
|
|
!rawPath
|
|
) {
|
|
return thingtime
|
|
}
|
|
const path = sanitise(rawPath)
|
|
console.log("Getting thingtime at path", path)
|
|
return smarts.getsmart(thingtime, path)
|
|
},
|
|
[thingtime]
|
|
)
|
|
|
|
React.useEffect(() => {
|
|
try {
|
|
window.setThingtime = setThingtime
|
|
window.thingtime = thingtime
|
|
} catch {
|
|
// nothing
|
|
}
|
|
|
|
const keyListener = (e) => {}
|
|
|
|
window.addEventListener("keydown", keyListener)
|
|
|
|
return () => {
|
|
window.removeEventListener("keydown", keyListener)
|
|
}
|
|
}, [setThingtime, thingtime])
|
|
|
|
const value = {
|
|
thingtime,
|
|
setThingtime,
|
|
getThingtime,
|
|
thingtimeRef,
|
|
}
|
|
|
|
return (
|
|
<ThingtimeContext.Provider value={value}>
|
|
{props?.children}
|
|
</ThingtimeContext.Provider>
|
|
)
|
|
}
|