): React.ReactElement | null;
+ }
+
+}
+
+export {};
diff --git a/remix/src/globals/GlobalStyles.tsx b/remix/src/globals/GlobalStyles.tsx
new file mode 100644
index 0000000..d5de8ec
--- /dev/null
+++ b/remix/src/globals/GlobalStyles.tsx
@@ -0,0 +1,15 @@
+import { Global } from '@emotion/react';
+
+export const Globals = () => {
+ return (
+
+ );
+};
diff --git a/remix/src/gp/GradientPath.js b/remix/src/gp/GradientPath.js
new file mode 100644
index 0000000..1ba1198
--- /dev/null
+++ b/remix/src/gp/GradientPath.js
@@ -0,0 +1,105 @@
+import { DEFAULT_PRECISION } from "./_constants"
+import { getData, strokeToFill } from "./_data"
+import { convertPathToNode, segmentToD, styleAttrs, svgElem } from "./_utils"
+
+export const GradientPath = class {
+ constructor({ path, segments, samples, precision = DEFAULT_PRECISION }) {
+ // If the path being passed isn't a DOM node already, make it one
+ this.path = convertPathToNode(path)
+
+ this.segments = segments
+ this.samples = samples
+ this.precision = precision
+
+ // Check if nodeName is path and that the path is closed, otherwise it's closed by default
+ this.pathClosed =
+ this.path.nodeName == "path"
+ ? this.path.getAttribute("d").match(/z/gi)
+ : true
+
+ // Store the render cycles that the user creates
+ this.renders = []
+
+ // Append a group to the SVG to capture everything we render and ensure our paths and circles are properly encapsulated
+ this.svg = path.closest("svg")
+ this.group = svgElem("g", {
+ class: "gradient-path",
+ })
+
+ // Get the data
+ this.data = getData({ path, segments, samples, precision })
+
+ // Append the main group to the SVG
+ this.svg.appendChild(this.group)
+
+ // Remove the main path once we have the data values
+ this.path.parentNode.removeChild(this.path)
+ }
+
+ remove() {
+ this.group.parentNode.removeChild(this.group)
+ }
+
+ render({
+ type,
+ stroke = ["white", "black", "white"],
+ strokeWidth = 1,
+ fill = ["white", "black", "white"],
+ width,
+ animation = {},
+ }) {
+ // Store information from this render cycle
+ const renderCycle = {}
+
+ // Create a group for each element
+ const elemGroup = svgElem("g", { class: `element-${type}` })
+
+ this.group.appendChild(elemGroup)
+ renderCycle.group = elemGroup
+
+ if (type === "path") {
+ // If we specify a width and fill, then we need to outline the path and then average the join points of the segments
+ // If we do not specify a width and fill, then we will be stroking and can leave the data "as is"
+ renderCycle.data =
+ width && fill
+ ? strokeToFill(this.data, width, this.precision, this.pathClosed)
+ : this.data
+
+ for (let j = 0; j < renderCycle.data.length; j++) {
+ const { samples, progress } = renderCycle.data[j]
+
+ // Create a path for each segment and append it to its elemGroup
+ elemGroup.appendChild(
+ svgElem("path", {
+ class: "path-segment",
+ d: segmentToD(samples),
+ ...styleAttrs(fill, stroke, strokeWidth, progress, animation),
+ })
+ )
+ }
+ } else if (type === "circle") {
+ renderCycle.data = this.data.flatMap(({ samples }) => samples)
+
+ for (let j = 0; j < renderCycle.data.length; j++) {
+ const { x, y, progress } = renderCycle.data[j]
+
+ // Create a circle for each sample and append it to its elemGroup
+ elemGroup.appendChild(
+ svgElem("circle", {
+ class: "circle-sample",
+ cx: x,
+ cy: y,
+ r: width / 2,
+ ...styleAttrs(fill, stroke, strokeWidth, progress, animation),
+ })
+ )
+ }
+ }
+
+ // Save the information in the current renderCycle and pop it onto the renders array
+ this.renders.push(renderCycle)
+
+ // Return this for method chaining
+ return this
+ }
+}
diff --git a/remix/src/gp/Sample.js b/remix/src/gp/Sample.js
new file mode 100644
index 0000000..19e8f62
--- /dev/null
+++ b/remix/src/gp/Sample.js
@@ -0,0 +1,8 @@
+export default class Sample {
+ constructor({ x, y, progress, segment }) {
+ this.x = x
+ this.y = y
+ this.progress = progress
+ this.segment = segment
+ }
+}
diff --git a/remix/src/gp/Segment.js b/remix/src/gp/Segment.js
new file mode 100644
index 0000000..c50c392
--- /dev/null
+++ b/remix/src/gp/Segment.js
@@ -0,0 +1,8 @@
+import { getMiddleSample } from "./_utils"
+
+export default class Segment {
+ constructor({ samples }) {
+ this.samples = samples
+ this.progress = getMiddleSample(samples).progress
+ }
+}
diff --git a/remix/src/gp/_constants.js b/remix/src/gp/_constants.js
new file mode 100644
index 0000000..fb0a370
--- /dev/null
+++ b/remix/src/gp/_constants.js
@@ -0,0 +1 @@
+export const DEFAULT_PRECISION = 2
diff --git a/remix/src/gp/_data.js b/remix/src/gp/_data.js
new file mode 100644
index 0000000..12017d3
--- /dev/null
+++ b/remix/src/gp/_data.js
@@ -0,0 +1,219 @@
+import { DEFAULT_PRECISION } from "./_constants"
+import { convertPathToNode } from "./_utils"
+import Sample from "./Sample"
+import Segment from "./Segment"
+
+// The main function responsible for getting data
+// This will take a path, number of samples, number of samples, and a precision value
+// It will return an array of Segments, which in turn contains an array of Samples
+// This can later be used to generate a stroked path, converted to outlines for a filled path, or flattened for plotting SVG circles
+export const getData = ({
+ path,
+ segments,
+ samples,
+ precision = DEFAULT_PRECISION,
+}) => {
+ // Convert the given path to a DOM node if it isn't already one
+ path = convertPathToNode(path)
+
+ // We decrement the number of samples per segment because when we group them later we will add on the first sample of the following segment
+ if (samples > 1) samples--
+
+ // Get total length of path, total number of samples we will be generating, and two blank arrays to hold samples and segments
+ const pathLength = path.getTotalLength(),
+ totalSamples = segments * samples,
+ allSamples = [],
+ allSegments = []
+
+ // For the number of total samples, get the x, y, and progress values for each sample along the path
+ for (let sample = 0; sample <= totalSamples; sample++) {
+ const progress = sample / totalSamples
+
+ let { x, y } = path.getPointAtLength(progress * pathLength)
+
+ // If the user asks to round our x and y values, do so
+ if (precision) {
+ x = +x.toFixed(precision)
+ y = +y.toFixed(precision)
+ }
+
+ // Create a new Sample and push it onto the allSamples array
+ allSamples.push(new Sample({ x, y, progress }))
+ }
+
+ // Out of all the samples gathered previously, sort them into groups of segments
+ // Each group includes the samples of the current segment, with the last sample being first sample from the next segment
+ for (let segment = 0; segment < segments; segment++) {
+ const currentStart = segment * samples,
+ nextStart = currentStart + samples,
+ segmentSamples = []
+
+ // Push all current samples onto segmentSamples
+ for (let samInSeg = 0; samInSeg < samples; samInSeg++) {
+ segmentSamples.push(allSamples[currentStart + samInSeg])
+ }
+
+ // Push the first sample from the next segment onto segmentSamples
+ segmentSamples.push(allSamples[nextStart])
+
+ // Create a new Segment with the samples from segmentSamples
+ allSegments.push(new Segment({ samples: segmentSamples }))
+ }
+
+ // Return our group of segments
+ return allSegments
+}
+
+// The function responsible for converting strokable data (from getData()) into fillable data
+// This allows any SVG path to be filled instead of just stroked, allowing for the user to fill and stroke paths simultaneously
+// We start by outlining the stroked data given a specified width and the we average together the edges where adjacent segments touch
+export const strokeToFill = (data, width, precision, pathClosed) => {
+ const outlinedStrokes = outlineStrokes(data, width, precision),
+ averagedSegmentJoins = averageSegmentJoins(
+ outlinedStrokes,
+ precision,
+ pathClosed
+ )
+
+ return averagedSegmentJoins
+}
+
+// An internal function for outlining stroked data
+const outlineStrokes = (data, width, precision) => {
+ // We need to get the points perpendicular to a startPoint, given an angle, radius, and precision
+ const getPerpSamples = (angle, radius, precision, startPoint) => {
+ const p0 = new Sample({
+ ...startPoint,
+ x: Math.sin(angle) * radius + startPoint.x,
+ y: -Math.cos(angle) * radius + startPoint.y,
+ }),
+ p1 = new Sample({
+ ...startPoint,
+ x: -Math.sin(angle) * radius + startPoint.x,
+ y: Math.cos(angle) * radius + startPoint.y,
+ })
+
+ // If the user asks to round our x and y values, do so
+ if (precision) {
+ p0.x = +p0.x.toFixed(precision)
+ p0.y = +p0.y.toFixed(precision)
+ p1.x = +p1.x.toFixed(precision)
+ p1.y = +p1.y.toFixed(precision)
+ }
+
+ return [p0, p1]
+ }
+
+ // We need to set the radius (half of the width) and have a holding array for outlined Segments
+ const radius = width / 2,
+ outlinedData = []
+
+ for (let i = 0; i < data.length; i++) {
+ const samples = data[i].samples,
+ segmentSamples = []
+
+ // For each sample point and the following sample point (if there is one) compute the angle
+ // Also compute the sample's various perpendicular points (with a distance of radius away from the sample point)
+ for (let j = 0; j < samples.length; j++) {
+ // If we're at the end of the segment and there are no further points, get outta here!
+ if (samples[j + 1] === undefined) break
+
+ const p0 = samples[j], // First point
+ p1 = samples[j + 1], // Second point
+ angle = Math.atan2(p1.y - p0.y, p1.x - p0.x), // Perpendicular angle to p0 and p1
+ p0Perps = getPerpSamples(angle, radius, precision, p0), // Get perpedicular points with a distance of radius away from p0
+ p1Perps = getPerpSamples(angle, radius, precision, p1) // Get perpedicular points with a distance of radius away from p1
+
+ // We only need the p0 perpendenciular points for the first sample
+ // The p0 for j > 0 will always be the same as p1 anyhow, so let's not add redundant points
+ if (j === 0) {
+ segmentSamples.push(...p0Perps)
+ }
+
+ // Always push the second sample point's perpendicular points
+ segmentSamples.push(...p1Perps)
+ }
+
+ // segmentSamples is out of order...
+ // Given a segmentSamples length of 8, the points need to be rearranged from: 0, 2, 4, 6, 7, 5, 3, 1
+ outlinedData.push(
+ new Segment({
+ samples: [
+ ...segmentSamples.filter((s, i) => i % 2 === 0),
+ ...segmentSamples.filter((s, i) => i % 2 === 1).reverse(),
+ ],
+ })
+ )
+ }
+
+ return outlinedData
+}
+
+// An internal function taking outlinedData (from outlineStrokes()) and averaging adjacent edges
+// If we didn't do this, our data would be fillable, but it would look stroked
+// This function fixes where segments overlap and underlap each other
+const averageSegmentJoins = (outlinedData, precision, pathClosed) => {
+ // Find the average x and y between two points (p0 and p1)
+ const avg = (p0, p1) => ({
+ x: (p0.x + p1.x) / 2,
+ y: (p0.y + p1.y) / 2,
+ })
+
+ // Recombine the new x and y positions with all the other keys in the object
+ const combine = (segment, pos, avg) => ({
+ ...segment[pos],
+ x: avg.x,
+ y: avg.y,
+ })
+
+ const init_outlinedData = JSON.parse(JSON.stringify(outlinedData)) //clone initial outlinedData Object
+
+ for (let i = 0; i < outlinedData.length; i++) {
+ // If path is closed: the current segment's samples;
+ // If path is open: the current segments' samples, as long as it's not the last segment; Otherwise, the current segments' sample of the initial outlinedData object
+ const currentSamples = pathClosed
+ ? outlinedData[i].samples
+ : outlinedData[i + 1]
+ ? outlinedData[i].samples
+ : init_outlinedData[i].samples,
+ // If path is closed: the next segment's samples, otherwise, the first segment's samples
+ // If path is open: the next segment's samples, otherwise, the first segment's samples of the initial outlinedData object
+ nextSamples = pathClosed
+ ? outlinedData[i + 1]
+ ? outlinedData[i + 1].samples
+ : outlinedData[0].samples
+ : outlinedData[i + 1]
+ ? outlinedData[i + 1].samples
+ : init_outlinedData[0].samples,
+ currentMiddle = currentSamples.length / 2, // The "middle" sample in the current segment's samples
+ nextEnd = nextSamples.length - 1 // The last sample in the next segment's samples
+
+ // Average two sets of outlined samples to create p0Average and p1Average
+ const p0Average = avg(currentSamples[currentMiddle - 1], nextSamples[0]),
+ p1Average = avg(currentSamples[currentMiddle], nextSamples[nextEnd])
+
+ // If the user asks to round our x and y values, do so
+ if (precision) {
+ p0Average.x = +p0Average.x.toFixed(precision)
+ p0Average.y = +p0Average.y.toFixed(precision)
+ p1Average.x = +p1Average.x.toFixed(precision)
+ p1Average.y = +p1Average.y.toFixed(precision)
+ }
+
+ // Replace the previous values with new Samples
+ currentSamples[currentMiddle - 1] = new Sample({
+ ...combine(currentSamples, currentMiddle - 1, p0Average),
+ })
+ currentSamples[currentMiddle] = new Sample({
+ ...combine(currentSamples, currentMiddle, p1Average),
+ })
+ nextSamples[0] = new Sample({
+ ...combine(nextSamples, 0, p0Average),
+ })
+ nextSamples[nextEnd] = new Sample({
+ ...combine(nextSamples, nextEnd, p1Average),
+ })
+ }
+
+ return outlinedData
+}
diff --git a/remix/src/gp/_utils.js b/remix/src/gp/_utils.js
new file mode 100644
index 0000000..96d8a9d
--- /dev/null
+++ b/remix/src/gp/_utils.js
@@ -0,0 +1,84 @@
+import tinygradient from "tinygradient"
+
+// An internal function to help with easily creating SVG elements with an object of attributes
+export const svgElem = (type, attrs) => {
+ const elem = document.createElementNS("http://www.w3.org/2000/svg", type),
+ attributes = Object.keys(attrs)
+
+ for (let i = 0; i < attributes.length; i++) {
+ const attr = attributes[i]
+
+ elem.setAttribute(attr, attrs[attr])
+ }
+
+ return elem
+}
+
+// An internal function to help with the repetition of adding fill, stroke, and stroke-width attributes
+export const styleAttrs = (fill, stroke, strokeWidth, progress, animation) => {
+ const determineColor = (type, progress) =>
+ typeof type === "string" ? type : tinygradient(type).rgbAt(progress)
+
+ const attrs = {}
+
+ if (stroke) {
+ attrs["stroke"] = determineColor(stroke, progress)
+ attrs["stroke-width"] = strokeWidth
+ }
+
+ if (fill) {
+ attrs["fill"] = determineColor(fill, progress)
+ }
+
+ if (animation?.name) {
+ // TODO: add animation-direction support
+
+ const duration = animation.duration || 5
+
+ attrs["style"] = `
+ animation-name: ${animation?.name};
+ animation-delay: ${progress * duration - duration}s;
+ animation-duration: ${duration}s;
+ animation-iteration-count: infinite;
+ animation-timing-function: linear;`
+ }
+
+ return attrs
+}
+
+// An internal function to convert any array of samples into a "d" attribute to be passed to an SVG path
+export const segmentToD = (samples) => {
+ let d = ""
+
+ for (let i = 0; i < samples.length; i++) {
+ const { x, y } = samples[i],
+ prevSample = i === 0 ? null : samples[i - 1]
+
+ if (i === 0 && i !== samples.length - 1) {
+ d += `M${x},${y}`
+ } else if (x !== prevSample.x && y !== prevSample.y) {
+ d += `L${x},${y}`
+ } else if (x !== prevSample.x) {
+ d += `H${x}`
+ } else if (y !== prevSample.y) {
+ d += `V${y}`
+ }
+
+ if (i === samples.length - 1) {
+ d += "Z"
+ }
+ }
+
+ return d
+}
+
+// An internal function for getting the colors of a segment, we need to get middle most sample (sorted by progress along the path)
+export const getMiddleSample = (samples) => {
+ const sortedSamples = [...samples].sort((a, b) => a.progress - b.progress)
+
+ return sortedSamples[(sortedSamples.length / 2) | 0]
+}
+
+// An internal function for converting any D3 selection or DOM-like element into a DOM node
+export const convertPathToNode = (path) =>
+ path instanceof Element || path instanceof HTMLDocument ? path : path.node()
diff --git a/remix/src/gp/index.js b/remix/src/gp/index.js
new file mode 100644
index 0000000..e3ad20c
--- /dev/null
+++ b/remix/src/gp/index.js
@@ -0,0 +1,2 @@
+export { default as GradientPath } from "./GradientPath"
+export { getData, strokeToFill } from "./_data"
diff --git a/remix/src/hooks/useIcons.tsx b/remix/src/hooks/useIcons.tsx
new file mode 100644
index 0000000..0e58af3
--- /dev/null
+++ b/remix/src/hooks/useIcons.tsx
@@ -0,0 +1,8 @@
+import { library } from "@fortawesome/fontawesome-svg-core"
+import { fas } from "@fortawesome/free-solid-svg-icons"
+
+library.add(fas)
+
+export const useIcons = () => {
+ return null
+}
diff --git a/app/src/hooks/usePath.tsx b/remix/src/hooks/usePath.tsx
similarity index 100%
rename from app/src/hooks/usePath.tsx
rename to remix/src/hooks/usePath.tsx
diff --git a/remix/src/hooks/useProps.tsx b/remix/src/hooks/useProps.tsx
new file mode 100644
index 0000000..a5c6576
--- /dev/null
+++ b/remix/src/hooks/useProps.tsx
@@ -0,0 +1,10 @@
+import React from "react"
+
+export const useProps = (allProps) => {
+ const deps = Object.values(allProps).filter((v) => v !== allProps.children)
+
+ return React.useMemo(() => {
+ const { children, ...other } = allProps
+ return other
+ }, deps)
+}
diff --git a/remix/src/hooks/useThings.tsx b/remix/src/hooks/useThings.tsx
new file mode 100644
index 0000000..8858051
--- /dev/null
+++ b/remix/src/hooks/useThings.tsx
@@ -0,0 +1,34 @@
+import React from "react"
+
+export const useThings = (props?: any) => {
+ const append = React.useCallback((args) => {
+ const { thing, value } = args
+
+ if (thing instanceof Array) {
+ const newValue = [...thing, value]
+ return newValue
+ }
+
+ if (typeof thing === "object") {
+ const newChildBasePath = "New Value"
+ // find increment that thing doesn't already have New Value N+1
+ let increment = 0
+ let newPath = newChildBasePath
+ while (Object.hasOwnProperty.call(thing, newPath) && increment <= 999) {
+ increment++
+ newPath = newChildBasePath + " " + increment
+ }
+ const newChildPath = newPath
+
+ const newValue = { ...thing }
+ newValue[newChildPath] = value
+ return newValue
+ }
+ }, [])
+
+ const ret = {
+ append,
+ }
+
+ return ret
+}
diff --git a/remix/src/hooks/useTrace.tsx b/remix/src/hooks/useTrace.tsx
new file mode 100644
index 0000000..74f6591
--- /dev/null
+++ b/remix/src/hooks/useTrace.tsx
@@ -0,0 +1,25 @@
+import React from "react"
+
+export const useTrace = (name, props) => {
+ const prev = React.useRef(props)
+ React.useEffect(() => {
+ const changedProps = Object.entries(props).reduce(
+ (changedValues, [key, newValue]) => {
+ window.trace = window.trace || {}
+ window.trace[key] = newValue
+ if (prev.current[key] !== newValue) {
+ changedValues[key] = {
+ old: prev.current[key],
+ new: newValue,
+ }
+ }
+ return changedValues
+ },
+ {}
+ )
+ if (Object.keys(changedProps)?.length) {
+ console.table({ TT: { name }, ...changedProps })
+ }
+ prev.current = props
+ })
+}
diff --git a/remix/src/hooks/useUuid.tsx b/remix/src/hooks/useUuid.tsx
new file mode 100644
index 0000000..02497db
--- /dev/null
+++ b/remix/src/hooks/useUuid.tsx
@@ -0,0 +1,11 @@
+import React from "react"
+
+export const useUuid = () => {
+ const [uuid, setUuid] = React.useState()
+
+ React.useEffect(() => {
+ setUuid(Math.random().toString(36).substring(7))
+ }, [])
+
+ return uuid
+}
diff --git a/app/src/root.tsx b/remix/src/root.tsx
similarity index 100%
rename from app/src/root.tsx
rename to remix/src/root.tsx
diff --git a/remix/src/routes/$.tsx b/remix/src/routes/$.tsx
new file mode 100644
index 0000000..fd6c456
--- /dev/null
+++ b/remix/src/routes/$.tsx
@@ -0,0 +1,22 @@
+import React from 'react';
+
+import { ThingtimeURL } from '~/components/Thingtime/ThingtimeURL';
+
+export default function Index() {
+ return ;
+}
+
+export const action = async ({ request }) => {
+ return {
+ status: 200,
+ headers: {
+ 'Content-Type': 'application/json'
+ },
+ body: {
+ message: 'Hello, World! $ Action'
+ },
+ cache: {
+ revalidate: 60
+ }
+ };
+};
diff --git a/app/src/routes/_index.tsx b/remix/src/routes/_index.tsx
similarity index 100%
rename from app/src/routes/_index.tsx
rename to remix/src/routes/_index.tsx
diff --git a/remix/src/routes/api/v1/login.tsx b/remix/src/routes/api/v1/login.tsx
new file mode 100644
index 0000000..2f18d59
--- /dev/null
+++ b/remix/src/routes/api/v1/login.tsx
@@ -0,0 +1,14 @@
+export const action = async ({ request }) => {
+ return {
+ status: 200,
+ headers: {
+ 'Content-Type': 'application/json'
+ },
+ body: {
+ message: 'Hello, World!'
+ },
+ cache: {
+ revalidate: 60
+ }
+ };
+};
diff --git a/remix/src/routes/edge.tsx b/remix/src/routes/edge.tsx
new file mode 100644
index 0000000..3f1fda5
--- /dev/null
+++ b/remix/src/routes/edge.tsx
@@ -0,0 +1,9 @@
+export const config = { runtime: "edge" }
+
+export default function Edge() {
+ return (
+
+
Welcome to Thingtime@Edge
+
+ )
+}
diff --git a/app/src/routes/login.tsx b/remix/src/routes/login.tsx
similarity index 100%
rename from app/src/routes/login.tsx
rename to remix/src/routes/login.tsx
diff --git a/app/src/routes/ode.tsx b/remix/src/routes/ode.tsx
similarity index 100%
rename from app/src/routes/ode.tsx
rename to remix/src/routes/ode.tsx
diff --git a/app/src/routes/rainbow.$.tsx b/remix/src/routes/rainbow.$.tsx
similarity index 100%
rename from app/src/routes/rainbow.$.tsx
rename to remix/src/routes/rainbow.$.tsx
diff --git a/remix/src/smarts/index.tsx b/remix/src/smarts/index.tsx
new file mode 100644
index 0000000..a6b92a8
--- /dev/null
+++ b/remix/src/smarts/index.tsx
@@ -0,0 +1,2876 @@
+import { v4 as uuidv4 } from "uuid"
+// import { Buffer } from 'buffer'
+// weird hack for remix client-side logic
+try {
+ window.process = {
+ env: {},
+ }
+ window.Buffer = () => {}
+ // window.Buffer = Buffer
+} catch (err) {
+ // nothing
+}
+
+// const babel = require('@babel/standalone')
+
+// babel.template = require('@babel/template').default
+// babel.t = require('@babel/types')
+// babel.generator = require('@babel/generator').default
+// babel.babylon = require('@babel/parser')
+// babel.prettier = require('prettier')
+
+const objList = []
+const stringList = []
+
+// ES6?
+// import { uuidv4 as uuid } from 'uuid'
+
+// import babel from '@babel/standalone'
+
+// import template from '@babel/template'
+// babel.template = template
+// import t from '@babel/types'
+// babel.t = t
+// import generator from '@babel/generator'
+// babel.generator = generator
+// import babylon from '@babel/parser'
+// babel.babylon = babylon
+// import prettier from 'prettier'
+// babel.prettier = prettier
+
+export const babel = () => {}
+export const local = {}
+export const t = () => {}
+// export const t = babel?.t
+
+export const getBabel = () => {
+ return babel
+}
+export const uuid = uuidv4
+export const pause = (value, opts) => {
+ return stringify(value, opts)
+}
+export const save = (value, opts) => {
+ return stringify(value, opts)
+}
+
+// extract parent path from dot delimitted path
+
+export const getParentPath = (path) => {
+ const parts = path?.split(".")
+ parts?.pop()
+ return parts?.join(".")
+}
+
+export const toJavascript = (value, opts = {}) => {
+ const defaultOpts = {
+ wrapInFunction: true,
+ declarations: [],
+ identifier: "obj",
+ keys: {
+ obj: 1,
+ },
+ dependancies: {},
+ mappings: [],
+ seen: [],
+ db: [],
+ }
+ Object.assign(defaultOpts, opts)
+ opts = defaultOpts
+ toJavascriptAux(value, opts)
+ // sort declarations by dependancies
+ for (const declaration of opts.declarations) {
+ if (declaration.type === "ExpressionStatement") {
+ // nothing
+ } else {
+ const key = declaration.declarations[0].id.name
+ const dependancies = opts.dependancies[key]
+ const dependancyCheck = {}
+ for (const dependancy of dependancies) {
+ dependancyCheck[dependancy] = false
+ }
+ let sortableDeclarationIndex = 0
+ let insertionIndex = 0
+ for (const sortableDeclaration of opts.declarations) {
+ if (sortableDeclaration.type === "ExpressionStatement") {
+ // nothing
+ } else {
+ const sortableDeclarationKey =
+ sortableDeclaration.declarations[0].id.name
+ if (dependancyCheck[sortableDeclarationKey] === false) {
+ insertionIndex = sortableDeclarationIndex + 1
+ dependancyCheck[sortableDeclarationKey] = true
+ }
+ }
+ // increment iterator index
+ sortableDeclarationIndex++
+ }
+ const declarationIndex = opts.declarations.indexOf(declaration)
+ opts.declarations.splice(declarationIndex, 1)
+ opts.declarations.splice(insertionIndex, 0, declaration)
+ }
+ }
+ let program
+ if (opts.wrapInFunction && !opts.moduleExport) {
+ opts.declarations.push(t.returnStatement(t.identifier("obj")))
+ const expression = t.expressionStatement(
+ t.callExpression(
+ t.functionExpression(null, [], t.blockStatement(opts.declarations)),
+ []
+ )
+ )
+ program = t.program([expression])
+ } else {
+ if (opts.moduleExport) {
+ opts.declarations.push(
+ t.expressionStatement(
+ t.assignmentExpression(
+ "=",
+ t.memberExpression(t.identifier("module"), t.identifier("exports")),
+ t.identifier("obj")
+ )
+ )
+ )
+ }
+ program = t.program(opts.declarations)
+ }
+ const stringifiedProgram = getBabel().generator(program).code
+ return getBabel().prettier.format(stringifiedProgram, {
+ semi: false,
+ parser: "babel",
+ useTabs: true,
+ })
+}
+export const toJavascriptAux = (value, opts) => {
+ if (typeof value === "object") {
+ if (!opts.seen.includes(value)) {
+ // update map and seen
+ opts.seen.push(value)
+ const properties = createObjectProperties(value, opts)
+ const declaration = t.variableDeclaration("let", [
+ t.variableDeclarator(
+ t.identifier(opts.identifier),
+ t.objectExpression(properties)
+ ),
+ ])
+ opts.declarations.unshift(declaration)
+ for (const key of Object.keys(value)) {
+ const property = properties.find((v) => {
+ return v.value.name === key
+ })
+ if (property) {
+ const identifier = property.value.name
+ toJavascriptAux(value[key], { ...opts, identifier })
+ }
+ }
+ }
+ } else if (typeof value === "string") {
+ const declaration = t.variableDeclaration("let", [
+ t.variableDeclarator(
+ t.identifier(opts.identifier),
+ t.stringLiteral(value)
+ ),
+ ])
+ opts.declarations.unshift(declaration)
+ }
+}
+export const createObjectProperties = (value, opts) => {
+ const properties = []
+ let dependancies = opts.dependancies[opts.identifier]
+ if (!dependancies) dependancies = opts.dependancies[opts.identifier] = []
+ for (const key of Object.keys(value)) {
+ if (value[key] === value) {
+ opts.declarations.push(
+ t.expressionStatement(
+ t.assignmentExpression(
+ "=",
+ t.memberExpression(
+ t.identifier(opts.identifier),
+ t.identifier(key)
+ ),
+ t.identifier(opts.identifier)
+ )
+ )
+ )
+ } else {
+ if (!opts.db.includes(value[key])) {
+ opts.db.push(value[key])
+ if (opts.keys[key] === undefined) {
+ opts.keys[key] = 1
+ }
+ const keyIncrement = opts.keys[key]
+ if (keyIncrement == 1) {
+ opts.mappings.push(key)
+ } else {
+ opts.mappings.push(key + keyIncrement)
+ }
+ opts.keys[key]++
+ }
+ const identifier = opts.mappings[opts.db.indexOf(value[key])]
+ dependancies.push(identifier)
+ properties.push(
+ t.objectProperty(
+ t.identifier(key),
+ t.identifier(identifier),
+ false,
+ key == identifier
+ )
+ )
+ }
+ }
+ return properties
+}
+export const serialize = (value, opts = {}) => {
+ opts.strictFunctions = false
+ opts.serializeArrayProps = true
+ return stringify(value, opts)
+}
+export const stringify = (value, opts = {}) => {
+ const schema = {
+ stringifier: stringifier,
+ replace(key, value) {
+ if (opts.firstRun) {
+ opts.firstRun = !opts.firstRun
+ return value
+ }
+ const after = opts.stringifier(key, value, opts)
+
+ const type = typeof after.value
+
+ if (type === "object") {
+ if (after === null || after.value === null) {
+ const ret = after.value
+ return ret
+ }
+ } else if (type === "string") {
+ const ret =
+ opts.known.get(after.key) || setKnown(opts.known, opts.input, after)
+ return ret
+ }
+
+ return after.value
+ },
+ strictFunctions: true,
+ firstRun: undefined,
+ known: new Map(),
+ input: [],
+ output: [],
+ }
+
+ Object.keys(schema).forEach((key) => {
+ if (getsmart(opts, epp(key), { undefined: true }, true).undefined == true) {
+ opts[key] = schema[key]
+ }
+ })
+
+ opts.virtual = opts.stringifier("", value, opts)
+ for (
+ let i = parseInt(setKnown(opts.known, opts.input, opts.virtual));
+ i < opts.input.length;
+ i++
+ ) {
+ opts.firstRun = true
+ try {
+ opts.output[i] = JSON.stringify(opts.input[i], opts.replace, opts.space)
+ } catch (err) {
+ console.error(err)
+ }
+ }
+ return "[" + opts.output.join(",") + "]"
+}
+export const replacer = (key, value) => {
+ const opts = opts || {}
+
+ if (opts.firstRun) {
+ opts.firstRun = !opts.firstRun
+ return value
+ }
+ const after = opts.stringifier(key, value, opts)
+ // replace with if statements
+
+ const type = typeof after.value
+
+ if (type === "object") {
+ if (after === null) {
+ const ret = after.value
+ return ret
+ }
+ } else if (type === "string") {
+ const ret =
+ opts.known.get(after.key) || setKnown(opts.known, opts.input, after)
+ return ret
+ }
+ return after.value
+}
+export const setKnown = (known, input, virtual) => {
+ const index = String(input.push(virtual.value) - 1)
+ known.set(virtual.key, index)
+ return index
+}
+export const stringifier = (key, val, opts) => {
+ let ret = { value: val, key: val }
+ if (
+ val instanceof Function &&
+ typeof val.toString === "function" &&
+ (!opts.strictFunctions || typeof val.$scopes != "undefined")
+ ) {
+ const known = opts.known.get(ret.key)
+ ret = {
+ value: known || {
+ type: "function",
+ js: val.toString(),
+ $scopes: val.$scopes,
+ $context: val.$context,
+ ...val,
+ },
+ key: val,
+ }
+ if (ret.value.js == "function () { [native code] }") return
+ if (typeof known == "undefined") setKnown(opts.known, opts.input, ret)
+ } else if (ret.value === Infinity && typeof ret.value != "string") {
+ const known = opts.known.get(ret.key)
+ ret = {
+ value: known || {
+ type: "number",
+ js: "Infinity",
+ $scopes: [],
+ $context: {},
+ },
+ key: val,
+ }
+ if (typeof known == "undefined") setKnown(opts.known, opts.input, ret)
+ } else if (typeof ret.value === "undefined") {
+ ret = {
+ value: {
+ type: "undefined",
+ js: "undefined",
+ },
+ key: val,
+ }
+ } else if (ret.value instanceof Array && opts.serializeArrayProps) {
+ const known = opts.known.get(ret.key)
+ ret = {
+ value: known
+ ? ret.value
+ : {
+ type: "Array",
+ js: ret.value,
+ uuid: ret.value.uuid,
+ },
+ key: val,
+ }
+ setKnown(opts.known, opts.input, ret)
+ }
+ return ret
+}
+export const primitives = (value) => {
+ return value instanceof String ? String(value) : value
+}
+export const Primitives = (key, value) => {
+ return typeof value === "string" ? new String(value) : value
+}
+export const play = (text, opts) => {
+ return parse(text, opts)
+}
+export const load = (text, opts = {}) => {
+ opts.strictFunctions = false
+ return parse(text, opts)
+}
+export const parse = (text, opts = {}) => {
+ const schema = {
+ // parser: eval('(function '+parser+')'),
+ parser: parser(opts),
+ value: {},
+ strictFunctions: true,
+ noFunctions: false,
+ firstPass: true,
+ output: new Map(),
+ }
+
+ Object.keys(schema).forEach((key) => {
+ if (getsmart(opts, epp(key), { undefined: true }, true).undefined == true) {
+ opts[key] = schema[key]
+ }
+ })
+
+ // opts.parser = opts.parser.bind(opts)
+ opts.input = JSON.parse(text, Primitives)
+ opts.firstPass = false
+ opts.input = opts.input.map(primitives)
+ opts.value = opts.input[0]
+ const isObject = typeof opts.value === "object" && opts.value
+ const tmp = isObject
+ ? revive(opts.input, opts.output, opts.value, opts.parser, opts)
+ : opts.value
+
+ opts.replaceMode = true
+ let ret = revive(opts.input, new Map(), tmp, opts.parser, opts)
+ ret = opts.parser("", tmp, opts)
+ return ret
+}
+export const parser = (opts) => {
+ return function (key, val) {
+ if (val.js && val.type === "Array") {
+ const ret = opts.input[opts.output.get(val)].js
+ ret.uuid = opts.input[opts.output.get(val)].uuid
+ return ret
+ } else if (
+ val.js &&
+ val.type === "function" &&
+ opts.replaceMode &&
+ !opts.noFunctions
+ ) {
+ let ret = opts.input[opts.output.get(val)]
+ if (typeof ret == val.type) return ret
+ const uuid = jsUUID()
+ let fn
+ let scopedEval
+ if (val.$scopedEval && typeof val.$scopedEval == "function") {
+ scopedEval = val.$scopedEval
+ } else {
+ const fns = createScopedEval(uuid)
+
+ try {
+ fn = eval(`(${fns})`)
+ const input = { val, smarts }
+ scopedEval = fn(input)
+ } catch (err) {
+ console.log("Caught error evaling createScopedEval", err)
+ }
+ }
+
+ ret = scopedEval({ val })
+ try {
+ Object.defineProperty(ret, "$scopes", {
+ value: val.$scopes,
+ enumerable: true,
+ })
+ if (val.uuid) {
+ ret.uuid = val.uuid
+ }
+ } catch (err) {
+ if (opts.verbose) console.error(err)
+ }
+ try {
+ Object.defineProperty(ret, "$context", {
+ value: val.$context,
+ enumerable: true,
+ })
+ } catch (err) {
+ if (opts.verbose) console.error(err)
+ }
+ try {
+ Object.defineProperty(ret, "$scopedEval", {
+ value: scopedEval,
+ enumerable: true,
+ })
+ } catch (err) {
+ if (opts.verbose) console.error(err)
+ }
+ opts.input[opts.output.get(val)] = ret
+ return ret
+ } else if (opts.replaceMode) {
+ return val
+ }
+ return Primitives(key, val)
+ }
+}
+export const revive = (input, parsed, output, parser, opts) => {
+ return Object.keys(output).reduce((output, key) => {
+ let value = output[key]
+ // if the value hasn't been revived yet
+ if (value instanceof String) {
+ const tmp = input[value]
+ if (typeof tmp === "object" && !parsed.get(tmp)) {
+ parsed.set(tmp, value)
+ output[key] = primitives(
+ parser(key, revive(input, parsed, tmp, parser, opts))
+ )
+ } else {
+ try {
+ output[key] = primitives(parser(key, tmp))
+ } catch (err) {
+ delete output[key]
+ }
+ }
+ } else {
+ try {
+ if (opts.replaceMode) {
+ // output[key] = primitives(parser(key, revive(input, parsed, value, parser, opts)))
+ value = parser(key, value)
+ if (typeof value === "object" && !parsed.get(value)) {
+ parsed.set(value, value)
+ output[key] = primitives(
+ parser(key, revive(input, parsed, value, parser, opts))
+ )
+ } else {
+ try {
+ output[key] = primitives(value)
+ } catch (err) {
+ delete output[key]
+ }
+ }
+ } else {
+ output[key] = primitives(parser(key, value))
+ }
+ } catch (err) {
+ delete output[key]
+ }
+ }
+ return output
+ }, output)
+}
+export const createScopedEval = (uuid) => {
+ const ret = /*javascript*/ `
+ function createScopedEval(${uuid}){
+
+ // scopeCode
+ ${uuid}.scopeCode = ${uuid}.scopeCode || ${uuid}.getBabel().template.ast('try{}catch(err){console.log(err)}')
+ ${uuid}.previousScopeCode = ${uuid}.currentScopeCode || ${uuid}.scopeCode
+ ${uuid}.currentScopeCode = ${uuid}.scopeCode.block.body.length ? ${uuid}.getBabel().template.ast('try{}catch(err){console.log(err)}') : ${uuid}.scopeCode
+ if(${uuid}.previousScopeCode != ${uuid}.currentScopeCode){
+ ${uuid}.previousScopeCode.block.body.push(
+ ${uuid}.currentScopeCode
+ )
+ }
+ ${uuid}.closureIndex = ${uuid}.closureIndex || 0
+ ${uuid}.closure = ${uuid}.getsmart.bind(this)(${uuid}, ${
+ /*javascript*/ `\`val.$scopes.\${${uuid}.closureIndex}\``
+ }, {})
+ ${uuid}.variableKeys = Object.keys(${uuid}.closure)
+ ${uuid}.variableMap = ${uuid}.getsmart.bind(this)(${uuid}, ${
+ /*javascript*/ `\`val.$context.$variableMaps.\${${uuid}.closureIndex}\``
+ }, [])
+ ${uuid}.allowedIdentifiers = ['let','var','const']
+ ${uuid}.variableKeys.forEach((key)=>{
+ if(
+ typeof ${uuid}.variableMap[key] == 'string'
+ && ${uuid}.allowedIdentifiers.indexOf(${uuid}.variableMap[key]) >= 0
+ ){
+ try{
+ ${uuid}.currentScopeCode.block.body.push(
+ ${uuid}.getBabel().template.ast(
+ ${
+ /*javascript*/ `\`
+ \${${uuid}.variableMap[key]} \${key} = ${uuid}.val.$scopes[\${${uuid}.closureIndex}]['\${key}']
+ \``
+ }
+ )
+ )
+ }catch(err){console.log(1,err)}
+ try{
+ ${uuid}.currentScopeCode.block.body.push(
+ ${uuid}.getBabel().template.ast(
+ ${
+ /*javascript*/ `\`
+ Object.defineProperty(
+ ${uuid}.val.$scopes[\${${uuid}.closureIndex}],
+ \${${uuid}.stringify(key)},
+ {
+ get(){
+ return \${key}
+ },
+ set(val){
+ \${key} = val
+ },
+ enumerable: true
+ }
+ )
+ \``
+ }
+ )
+ )
+ }catch(err){console.log(2,err)}
+ }
+ // console.log(${uuid}.scopeCode)
+ })
+ // console.log(${uuid}.scopeCode)
+ ${uuid}.closureIndex++
+ if(${uuid}.closureIndex >= ${uuid}.getsmart.bind(this)(${uuid}, 'val.$scopes.length', -1)){
+ // console.log(${uuid}.scopeCode)
+ try{
+ ${uuid}.currentScopeCode.block.body.push(
+ ${uuid}.getBabel().template.ast(
+ ${
+ /*javascript*/ `\`
+ return \${${uuid}.scopedEval('${uuid}')}
+ \``
+ }
+ )
+ )
+ }catch(err){console.log(3,err)}
+ try{
+ ${uuid}.wrapper = ${uuid}.getBabel().template.ast(
+ ${
+ /*javascript*/ `\`
+ function anonymous(){}
+ \``
+ }
+ )
+ }catch(err){console.log(4,err)}
+ // console.log(${uuid}.wrapper)
+ // console.log(${uuid}.scopeCode)
+ ${uuid}.wrapper.body.body.push(${uuid}.scopeCode)
+ ${uuid}.scopeCode = ${uuid}.wrapper
+ ${uuid}.scopeCode = ${uuid}.getBabel().generator(
+ ${uuid}.scopeCode
+ ).code
+ // console.log(${uuid}.scopeCode)
+ ${uuid}.scopeCode = eval("("+${uuid}.scopeCode+")")
+ // console.log(${uuid}.scopeCode.toString())
+ try {
+ ${uuid}.val.$scopedEval = ${uuid}.scopeCode()
+ }catch(err){console.log(5,err)}
+ // console.log(${uuid}.val.$scopedEval)
+ // return ${uuid}.scopeCode.toString()
+ return ${uuid}.val.$scopedEval
+ } else {
+ return eval(${
+ /*javascript*/ `\`(\${${uuid}.createScopedEval('${uuid}')})\``
+ })(${uuid})
+ }
+ }
+ `
+ return ret
+}
+export const defineVariable = (uuid) => {
+ return /*javascript*/ `
+ ${uuid.variableType} ${uuid.variableKey} = ${uuid}.$scope[${uuid}.variableKey]
+ Object.defineProperty(
+ ${uuid}.$scope,
+ ${uuid}.variableKey,
+ {
+ get(){
+ return ${uuid.variableKey}
+ },
+ set(val){
+ ${uuid.variableKey} = val
+ },
+ enumerable: true
+ }
+ )
+ `
+}
+export const scopedEval = (uuid) => {
+ const ret = /*javascript*/ `function scopedEval(${uuid}){
+ if(typeof ${uuid} == 'string'){
+ ${uuid} = {
+ val: {
+ js: ${uuid}
+ }
+ }
+ } else if(typeof ${uuid} == 'function' && typeof ${uuid}.toString == 'function'){
+ ${uuid} = {
+ val: {
+ js: ${uuid}.toString()
+ }
+ }
+ }
+ try {
+ ${uuid}.ret = eval('('+${uuid}.val.js+')')
+ } catch(err1){
+ try {
+ ${uuid}.ret = eval('({'+${uuid}.val.js+'})')
+ ${uuid}.keys = Object.keys(${uuid}.ret)
+ ${uuid}.ret = ${uuid}.ret[${uuid}.keys[0]]
+ } catch(err2){
+ try {
+ ${uuid}.ret = eval('({b:'+ ${uuid}.val.js +'})').b
+ } catch(err3){
+ console.error(err1)
+ console.error(err2)
+ console.error(err3)
+ }
+ }
+ }
+ return ${uuid}.ret
+ }
+ `
+ return ret
+}
+export const jsUUID = (prefix = "uuid") => {
+ return prefix + uuid().replace(/-/g, "")
+}
+export const context = (opts) => {
+ const uuid = gosmart.bind(this)(opts, "path.context.scope.uuid", jsUUID())
+ return eval(/*javascript*/ `
+ (
+ function(){
+ ${contextObject(uuid)}
+ return ${uuid}
+ }
+ )()
+ `)
+}
+export const contextObject = (uuid) => {
+ return /*javascript*/ `
+ let ${uuid} = {
+ $$uuid: '${uuid}',
+ $closure: {},
+ $variableMap: {},
+ $functionScoper: (func)=>{
+ Object.defineProperty(
+ func,
+ '$scopes',
+ {
+ value: (function(arr){
+ for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {
+ arr2[i] = arr[i];
+ }
+ return arr2
+ })((typeof ${uuid} != 'undefined') ? ${uuid}.$scopes : []),
+ enumerable: true
+ }
+ )
+ Object.defineProperty(
+ func,
+ '$context',
+ {
+ value: ${uuid}
+ }
+ )
+ return func
+ },
+ $add: (type, name, value)=>{
+ ${uuid}.$closure[name] = value
+ ${uuid}.$variableMap[name] = type
+ },
+ $scopes: (function(arr){
+ for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {
+ arr2[i] = arr[i];
+ }
+ return arr2
+ })((typeof $context == 'object') ? $context.$scopes : []),
+ $variableMaps: (function(arr){
+ for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {
+ arr2[i] = arr[i];
+ }
+ return arr2
+ })((typeof $context == 'object') ? $context.$variableMaps : []),
+ $contexts: {},
+ $contextsList: [],
+ $parentContexts: [],
+ $contextStatus: "var",
+ $mode: (eval("var ${uuid}1 = null"), (typeof ${
+ uuid + "1"
+ } === "undefined")) ? "strict" : "non-strict",
+ }
+ ${uuid}.$functionScoper = ${uuid}.$functionScoper(${uuid}.$functionScoper)
+ ${uuid}.$scopes.splice(0,0,${uuid}.$closure)
+ ${uuid}.$variableMaps.splice(0,0,${uuid}.$variableMap)
+ var globalThis = globalThis || global || window || {}
+ ${uuid}.$contextStatus = ${uuid}.$mode == 'strict' ? '' : 'var'
+ try {
+ eval(${
+ /*javascript*/ `\`\${${uuid}.$contextStatus} $context = $context || ${uuid}\``
+ })
+ } catch(err){
+ ${uuid}.$contextStatus = ''
+ }
+ eval(${
+ /*javascript*/ `\`\${${uuid}.$contextStatus} $context = $context || ${uuid}\``
+ })
+ if(typeof $context == 'object' && $context != ${uuid} && $context.$contexts instanceof Object){
+ $context.$contexts[${uuid}.$$uuid] = $context.$contexts[${uuid}.$$uuid] || []
+ ${uuid}.$$instance = $context.$contexts[${uuid}.$$uuid].push(${uuid})-1
+ ${uuid}.$parentContexts.push($context)
+ $context.$contextsList.push(${uuid})
+ }
+ if(!globalThis.$contexts){
+ globalThis.$contexts = {}
+ globalThis.$contexts[${uuid}.$$uuid] = [${uuid}]
+ globalThis.$contextsList = [${uuid}]
+ ${uuid}.$$instance = 0
+ } else if(
+ globalThis.${uuid}s instanceof Object
+ && ${uuid}.$parentContexts.length == 0
+ && typeof ${uuid}.$$instance == 'undefined'
+ ){
+ globalThis.${uuid}s[${uuid}.$$uuid] = globalThis.$contexts[${uuid}.$$uuid] || []
+ ${uuid}.$$instance = globalThis.$contexts[${uuid}.$$uuid].push(${uuid})-1
+ globalThis.$contextsList.push(${uuid})
+ }
+ {
+ let $context = ${uuid}
+ }
+ `
+}
+export const createContext = (opts) => {
+ schema(opts, {
+ wrapBody: true,
+ })
+ const node = opts.aster(/*javascript*/ `
+ ${contextObject(opts.uuid)}
+ `)
+ node[0].declarations[0].contextDeclaration = true
+ // so the $functionScoper function doesn't get wrapped or have $context inserted
+ const property3 = node[0].declarations[0].init.properties[3]
+ property3.value.scoperWrapped = true
+ property3.value.body.scopeInitialized = true
+ const property3ScopesValue =
+ property3.value.body.body[0].expression.arguments[2].properties[0].value
+ property3ScopesValue.callee.scoperWrapped = true
+ property3ScopesValue.callee.body.scopeInitialized = true
+ const property3ForStatement = property3ScopesValue.callee.body.body[0]
+ property3ForStatement.body.scopeInitialized = true
+ property3ForStatement.init.declarations[0].inScope = true
+ property3ForStatement.init.declarations[1].inScope = true
+ // so the $add function doesn't get wrapped or have $context inserted
+ const property4 = node[0].declarations[0].init.properties[4]
+ property4.value.scoperWrapped = true
+ property4.value.body.scopeInitialized = true
+ // so the $scopes self-invoking function doesn't get wrapped or have $context inserted
+ const property5 = node[0].declarations[0].init.properties[5]
+ property5.value.callee.scoperWrapped = true
+ property5.value.callee.body.scopeInitialized = true
+ const property5ForStatement = property5.value.callee.body.body[0]
+ property5ForStatement.body.scopeInitialized = true
+ property5ForStatement.init.declarations[0].inScope = true
+ property5ForStatement.init.declarations[1].inScope = true
+ // so the $variableMaps self-invoking function doesn't get wrapped or have $context inserted
+ const property6 = node[0].declarations[0].init.properties[6]
+ property6.value.callee.scoperWrapped = true
+ property6.value.callee.body.scopeInitialized = true
+ const property6ForStatement = property6.value.callee.body.body[0]
+ property6ForStatement.body.scopeInitialized = true
+ property6ForStatement.init.declarations[0].inScope = true
+ property6ForStatement.init.declarations[1].inScope = true
+ const node6 = node[6]
+ // make sure try statement block doesn't get scoped either
+ node6.block.scopeInitialized = true
+ // make sure catch statement block doesn't get scoped either
+ node6.handler.body.scopeInitialized = true
+ const node8 = node[8]
+ // make sure if statement block doesn't get scoped either
+ node8.consequent.scopeInitialized = true
+ const node9 = node[9]
+ // make sure if statement block doesn't get scoped either
+ node9.consequent.scopeInitialized = true
+ // make sure else if statement block doesn't get scoped either
+ node9.alternate.consequent.scopeInitialized = true
+ const node10 = node[10]
+ node10.scopeInitialized = true
+ node10.inheritScope = true
+ node[node.length - 1].lastContextNode = true
+ if (opts.wrapBody) {
+ const bodyWrapper = node[node.length - 1]
+ bodyWrapper.body.push(...opts.path.node.body)
+ }
+ addBindingsToContext({ ...opts, node })
+ // let addContextToScopeNode = scopeVar({
+ // uuid,
+ // key: '$context',
+ // type: 'let',
+ // aster
+ // })
+ // wrapper.body.splice(1,0,addContextToScopeNode)
+ return node
+}
+export const createInlineContext = (opts) => {
+ const wrapperString = /*javascript*/ `
+ for(let ${opts.uuid} = function(){
+ // node goes here
+ return ${opts.uuid}
+ }() ; a<1;a++){}
+ `
+ const inlineContextNode = opts.aster(wrapperString).init.declarations[0]
+ const contextBody = createContext({ ...opts, wrapBody: false })
+ inlineContextNode.init.callee.body.body.splice(0, 0, ...contextBody)
+ inlineContextNode.contextDeclaration = true
+ return inlineContextNode
+}
+export const addBindingsToContext = (opts) => {
+ for (const key in opts.path.scope.bindings) {
+ const binding = opts.path.scope.bindings[key]
+ if (binding.kind == "var") {
+ const newNode = scopeVar({
+ ...opts,
+ key,
+ type: binding.kind,
+ })
+ opts.node.splice(opts.node.length - 1, 0, newNode)
+ }
+ }
+}
+export const scopeVarCode = (opts) => {
+ const ret = /*javascript*/ `
+ Object.defineProperty(
+ ${opts.uuid}.$closure,
+ ${stringify(opts.key)},
+ {
+ get(){
+ return ${opts.key}
+ },
+ set(val){
+ ${opts.key} = val
+ },
+ enumerable: true
+ }
+ ) &&
+ (${opts.uuid}.$variableMap["${opts.key}"] = "${opts.type}")
+ `
+ return ret
+}
+export const scopeVarInlineCode = (opts) => {
+ const ret = /*javascript*/ `
+ let ${jsUUID()} = (
+ ${scopeVarCode(opts)}
+ )
+ `
+ return ret
+}
+export const scopeVar = (opts = {}) => {
+ let string
+ let thirdArg
+ let node
+ if (opts.inline) {
+ string = scopeVarInlineCode(opts)
+ node = opts.aster(string)
+ thirdArg = node.declarations[0].init.left.arguments[2]
+ node.declarations[0].inScope = true
+ } else {
+ string = scopeVarCode(opts)
+ node = opts.aster(string)
+ thirdArg = node.expression.left.arguments[2]
+ }
+
+ const getter = thirdArg.properties[0]
+ const setter = thirdArg.properties[1]
+ getter.body.scopeInitialized = true
+ setter.body.scopeInitialized = true
+ getter.body.scoperWrapped = true
+ setter.body.scoperWrapped = true
+ getter.scoperWrapped = true
+ setter.scoperWrapped = true
+ if (opts.inline) return node.declarations[0]
+ return node
+}
+export const functionWrapper = (uuid, path, aster) => {
+ const wrapper = aster(/*javascript*/ `
+ ${uuid}.$functionScoper()
+ `)
+ wrapper.expression.arguments.push(path.node)
+ return wrapper
+}
+export const bodyInsert = (index, body, aster, ...things) => {
+ body.splice(index, 0, ...things)
+ return things.length
+}
+export const initBlock = (path, aster) => {
+ if (!path.node.scopeInitialized) {
+ path.node.scopeInitialized = true
+ const uuid = getPathUUID({ path })
+ const contextNode = createContext({ uuid, aster, path })
+ path.node.body = contextNode
+ }
+}
+export const getNodeUUID = (opts) => {
+ if (
+ opts.node &&
+ opts.node.type != "BlockStatement" &&
+ opts.node.type != "Program"
+ )
+ return getNodeUUID({
+ ...opts,
+ node: opts.node.body || opts.node.block,
+ })
+ return gosmart.bind(this)(opts.node, "uuid", jsUUID())
+}
+export const getPathUUID = (opts) => {
+ if (
+ opts.path.context.scope.path.node.inheritScope ||
+ opts.path.scope.path.node.inheritScope
+ )
+ return getPathUUID({ ...opts, path: opts.path.parentPath })
+ return getNodeUUID({
+ ...opts,
+ node: opts.path.context.scope.path.node,
+ })
+}
+export const babelPlugin = (babel) => {
+ const aster = babel.template.ast
+
+ const metaVisitor = {
+ Program(path) {
+ initBlock(path, aster)
+ },
+ BlockStatement(path) {
+ initBlock(path, aster)
+ },
+ ForInStatement() {
+ // nothing
+ },
+ // ForInStatement (path) {
+ // path = path
+ // },
+ ObjectMethod(path) {
+ const name = path.node.key.name
+ let replacement = aster(/*javascript*/ `
+ let a = {
+ ${name}: function ${name}(){}
+ }
+ `)
+ replacement = replacement.declarations[0].init.properties[0]
+ replacement.value.body = path.node.body
+ replacement.value.params = path.node.params
+ path.replaceWith(replacement)
+ },
+ Function(path) {
+ if (
+ path.type != "FunctionDeclaration" &&
+ !path.node.scoperWrapped &&
+ !path.node.body.scoperWrapped
+ ) {
+ path.node.scoperWrapped = true
+ path.node.body.scoperWrapped = true
+ const uuid = getPathUUID({ path })
+ const replacement = functionWrapper(uuid, path, aster)
+ path.replaceWith(replacement)
+ }
+ },
+ FunctionDeclaration(path) {
+ if (!path.node.scoped) {
+ path.node.scoped = true
+ const parentBlock = path.scope.parent
+ try {
+ parentBlock.block.body.forEach((node) => {
+ if (node.lastContextNode) {
+ const uuid = getPathUUID({ path })
+ const newNode = aster(/*javascript*/ `
+ ${uuid}.$functionScoper(${path.node.id.name})
+ `)
+ node.body.splice(1, 0, newNode)
+ throw new Error("break foreach")
+ }
+ })
+ } catch (err) {
+ // nothing
+ }
+ }
+ },
+ VariableDeclarator(path) {
+ if (!path.node.inScope) {
+ path.node.inScope = true
+ const parentPath = getsmart.bind(this)(path, "parentPath", undefined)
+ if (
+ // this is for inline let and const declarations in normal
+ // js blocks
+ (parentPath.node.kind == "let" || parentPath.node.kind == "const") &&
+ // we check the length of declarations because we only have to do inline replacement
+ // if there's a chance another declaration might use a former one
+ parentPath.node.declarations.length > 1 &&
+ !(
+ parentPath.parentPath.node.type == "ForInStatement" ||
+ parentPath.parentPath.node.type == "ForOfStatement" ||
+ parentPath.parentPath.node.type == "ForStatement"
+ )
+ ) {
+ const uuid = getPathUUID({ path })
+ if (uuid) {
+ const indexInParent = parentPath.node.declarations.indexOf(
+ path.node
+ )
+ const newDeclaration = scopeVar({
+ aster,
+ inline: true,
+ uuid,
+ key: parentPath.node.declarations[indexInParent].id.name,
+ type: parentPath.node.kind,
+ })
+ parentPath.node.declarations.splice(
+ indexInParent + 1,
+ 0,
+ newDeclaration
+ )
+ }
+ } else if (
+ //
+ (parentPath.node.kind == "let" ||
+ parentPath.node.kind == "var" ||
+ parentPath.node.kind == "const") &&
+ // only do this for singular declarations
+ parentPath.node.declarations.length < 2 &&
+ // and check if variable is declared inside a ForX statement
+ (parentPath.parentPath.node.type == "ForInStatement" ||
+ parentPath.parentPath.node.type == "ForOfStatement" ||
+ parentPath.parentPath.node.type == "ForStatement")
+ ) {
+ const uuid = getPathUUID({ path })
+ if (uuid) {
+ const indexInParent = parentPath.node.declarations.indexOf(
+ path.node
+ )
+ const newNode = scopeVar({
+ aster,
+ uuid,
+ key: parentPath.node.declarations[indexInParent].id.name,
+ type: parentPath.node.kind,
+ })
+ parentPath.parentPath.node.body.body.splice(0, 0, newNode)
+ }
+ } else if (
+ // this is a special case for when ForStatements get their own scope
+ (parentPath.node.kind == "let" || parentPath.node.kind == "const") &&
+ // we check the length of declarations because we only have to do inline replacement
+ // if there's a chance another declaration might use a former one
+ parentPath.node.declarations.length > 1 &&
+ parentPath.parentPath.node.type == "ForStatement"
+ ) {
+ // if the first declaration isn't our context declaration, insert one
+ const uuid = gosmart.bind(this)(path, "scope.uuid", jsUUID())
+ if (!parentPath.node.declarations[0].contextDeclaration) {
+ const inlineContextDeclaration = createInlineContext({
+ path,
+ uuid,
+ aster,
+ })
+ parentPath.node.declarations.splice(0, 0, inlineContextDeclaration)
+ }
+ if (uuid) {
+ const indexInParent = parentPath.node.declarations.indexOf(
+ path.node
+ )
+ const newDeclaration = scopeVar({
+ aster,
+ inline: true,
+ uuid,
+ key: parentPath.node.declarations[indexInParent].id.name,
+ type: parentPath.node.kind,
+ })
+ parentPath.node.declarations.splice(
+ indexInParent + 1,
+ 0,
+ newDeclaration
+ )
+ }
+ } else if (
+ parentPath.node.kind == "let" ||
+ parentPath.node.kind == "const"
+ ) {
+ const uuid = getPathUUID({ path })
+ if (uuid) {
+ const indexInParent = parentPath.node.declarations.indexOf(
+ path.node
+ )
+ const newNode = scopeVar({
+ aster,
+ uuid,
+ key: parentPath.node.declarations[indexInParent].id.name,
+ type: parentPath.node.kind,
+ })
+ parentPath.insertAfter(newNode)
+ }
+ } else {
+ // let uuid = getPathUUID({path})
+ // if(uuid){
+ // let indexInParent = parentPath.node.declarations.indexOf(path.node)
+ // let newNode = scopeVar({
+ // aster,
+ // uuid,
+ // key: parentPath.node.declarations[indexInParent].id.name,
+ // type: parentPath.node.kind
+ // })
+ // parentPath.insertAfter(newNode)
+ // }
+ }
+ }
+ },
+ }
+ const ret = {
+ visitor: metaVisitor,
+ // visitor: {
+ // Program(path){
+ // path.traverse(metaVisitor)
+ // }
+ // }
+ }
+ return ret
+}
+export const transform = (src, opts = {}) => {
+ return getBabel().transform(src, {
+ plugins: [babelPlugin],
+ ...opts,
+ })
+}
+/** non-parser stuff */
+export const stripUuids = (thing, seen = []) => {
+ try {
+ delete thing.uuid
+ } catch {
+ // nothing
+ }
+ if (typeof thing === "object") {
+ const keys = Object.keys(thing)
+ for (const key of keys) {
+ const val = thing[key]
+ if (!seen.includes(val)) {
+ seen.push(val)
+ stripUuids(val, seen)
+ }
+ }
+ }
+}
+export const dupe = (obj, opts = {}) => {
+ return parse(stringify(obj, opts), opts)
+}
+export const clone = (obj, opts = {}) => {
+ return dupe(obj, opts)
+}
+export const schema = (obj1, obj2, opts = {}) => {
+ if (!opts.noSchemaClone) {
+ obj2 = clone(obj2, opts)
+ }
+ return merge(obj1, obj2, {
+ ...opts,
+ })
+}
+export const create = (obj1, obj2, opts) => {
+ const ret = merge(obj1, obj2, {
+ clone: true,
+ ...opts,
+ })
+
+ return ret
+}
+export const merge = (value1, value2, opts = {}, seen = new Map()) => {
+ if (seen.has(value1)) return seen.get(value1)
+
+ if (value1 instanceof Array && value2 instanceof Array) {
+ return value1
+ }
+
+ // base case non-basic value
+ if (basic(value1) && !opts.overwrite) {
+ return value1
+ }
+
+ if (opts.overwrite && basic(value2)) {
+ return value2
+ }
+
+ if (!basic(value1) && basic(value2)) {
+ return value1
+ }
+
+ if (opts.clone) {
+ value1 = clone(value1)
+ value2 = clone(value2)
+ }
+
+ const props = Object.keys(value2)
+
+ props.forEach((prop) => {
+ const propertyValue1 = value1[prop]
+ if (prop in value1 && basic(propertyValue1) && !opts.overwrite) {
+ return
+ }
+ const propertyValue2 = value2[prop]
+ seen.set(value1, value1)
+ let newVal = propertyValue2
+ if (prop in value1) {
+ newVal = merge.bind(this)(
+ propertyValue1,
+ propertyValue2,
+ { ...opts, ...{ clone: false } },
+ seen
+ )
+ }
+ if (
+ getsmart.bind(this)(local.vue, "reactiveSetter", false) &&
+ getsmart.bind(this)(
+ this,
+ "$set",
+ getsmart.bind(this)(local.vue, "Vue.set", false)
+ ) &&
+ value1
+ ) {
+ const setToUse = this.$set || local.vue.Vue.set
+ setToUse?.(value1, prop, newVal)
+ if (
+ typeof getsmart.bind(this)(window, "$store.commit", undefined) ==
+ "function"
+ ) {
+ window.$store.commit(local.vue.basePath || "graph/thing")
+ }
+ } else {
+ value1[prop] = newVal
+ if (
+ getsmart.bind(this)(local.vue, "store", false) &&
+ typeof getsmart.bind(this)(window, "$store.commit", undefined) ==
+ "function"
+ ) {
+ window.$store.commit(local.vue.basePath || "graph/thing")
+ }
+ }
+ })
+
+ return value1
+}
+export const basic = (value) => {
+ const valueType = typeof value
+ const ret =
+ !(
+ valueType == "object" ||
+ valueType == "array" ||
+ valueType == "function"
+ ) || value === null
+ return ret
+}
+export const mod = (args, mod) => {
+ return mod(args) || args
+}
+// transform(value, fn, path, ret={}){
+// return forEach(value, fn, path, ret)
+// },
+export const deepForEach = (
+ value,
+ fn,
+ path,
+ ret = {},
+ seens = { originals: [], clones: [] },
+ first = true
+) => {
+ path = path || ""
+ if (first) {
+ value = { "": value }
+ }
+ // if(!(typeof value == 'string' || typeof value == 'boolean' || typeof value == 'number')){
+ // seens.originals.push(value)
+ // }
+ if (Array.isArray(value)) {
+ forEachArray(value, fn, path, ret, seens)
+ } else if (typeof value == "object") {
+ forEachObject(value, fn, path, ret, seens)
+ }
+ return ret[""]
+}
+export const forEachObject = (obj, fn, path, ret, seens) => {
+ for (const key in obj) {
+ const deepPath = path ? `${path}.${key}` : key
+ const primitive =
+ typeof obj[key] == "string" ||
+ typeof obj[key] == "boolean" ||
+ typeof obj[key] == "number"
+ if (primitive || seens.originals.indexOf(obj[key]) < 0) {
+ if (!primitive) {
+ seens.originals.push(obj[key])
+ }
+ // Note that we always use obj[key] because it might be mutated by forEach
+ fn(obj[key], key, obj, deepPath, ret, seens)
+
+ deepForEach(obj[key], fn, deepPath, ret, seens, false)
+ }
+ }
+}
+export const forEachArray = (array, fn, path, ret = {}, seens) => {
+ array.forEach((value, index, arr) => {
+ const primitive =
+ typeof value == "string" ||
+ typeof value == "boolean" ||
+ typeof value == "number"
+ if (primitive || seens.originals.indexOf(value) < 0) {
+ if (!primitive) {
+ seens.originals.push(value)
+ }
+ const deepPath = `${path}.${index}`
+
+ fn(value, index, arr, deepPath, ret, seens)
+
+ // Note that we use arr[index] because it might be mutated by forEach
+ deepForEach(arr[index], fn, deepPath, ret, seens, false)
+ }
+ })
+}
+export const setThing = ({
+ option,
+ list = getsmart.bind(this)(objList),
+ obj = true,
+ keys = ["uuid", "_id", "id"],
+ keymatchtype,
+ push,
+ strings,
+ targets,
+} = {}) => {
+ let index = thingIndex({
+ option,
+ list,
+ obj,
+ keys,
+ keymatchtype,
+ strings,
+ })
+ if (obj == "debug") {
+ console.log("index")
+ console.log(index)
+ console.log("list")
+ console.log(list)
+ }
+ if (index >= 0 && list) {
+ if (targets && targets.length && typeof targets.length == "number") {
+ for (let i = 0; i < targets.length; i++) {
+ const value = getsmart.bind(this)(option, targets[i], undefined)
+ if (value) {
+ setsmart.bind(this)(list[index], targets[i], value)
+ }
+ }
+ } else {
+ list.splice(index, 1, option)
+ if (
+ getsmart.bind(this)(local.vue, "reactiveSetter", false) &&
+ getsmart.bind(this)(
+ this,
+ "$set",
+ getsmart.bind(this)(local.vue, "Vue.set", false)
+ )
+ ) {
+ if (
+ !localStorage.getItem("vuexWriteLock") &&
+ typeof getsmart.bind(this)(window, "$store.commit", undefined) ==
+ "function"
+ ) {
+ window.$store.commit(local.vue.basePath || "graph/thing")
+ }
+ } else if (
+ getsmart.bind(this)(local.vue, "store", false) &&
+ !localStorage.getItem("vuexWriteLock") &&
+ typeof getsmart.bind(this)(window, "$store.commit", undefined) ==
+ "function"
+ ) {
+ window.$store.commit(local.vue.basePath || "graph/thing")
+ }
+ }
+ // list[index] = option
+ } else if (push && list) {
+ if (
+ getsmart.bind(this)(local.vue, "reactiveSetter", false) ||
+ getsmart.bind(this)(local.vue, "store", false)
+ ) {
+ list.splice(list.length, 0, option)
+ if (
+ !localStorage.getItem("vuexWriteLock") &&
+ typeof getsmart.bind(this)(window, "$store.commit", undefined) ==
+ "function"
+ ) {
+ window.$store.commit(local.vue.basePath || "graph/thing")
+ }
+ } else {
+ list.push(option)
+ }
+ index = list.length - 1
+ }
+ return index
+}
+export const setThings = ({
+ options,
+ list = getsmart.bind(this)(objList),
+ obj = true,
+ keys = ["uuid", "_id", "id"],
+ keymatchtype,
+ push,
+ async,
+} = {}) => {
+ if (options && options instanceof Array && list) {
+ for (const option of options) {
+ if (async) {
+ new Promise(() => {
+ setThing({
+ option,
+ list,
+ obj,
+ keys,
+ keymatchtype,
+ push,
+ })
+ })
+ } else {
+ setThing({
+ option,
+ list,
+ obj,
+ keys,
+ keymatchtype,
+ push,
+ })
+ }
+ }
+ }
+ return list
+}
+export const optIn = (
+ option,
+ list = getsmart.bind(this)(stringList),
+ obj,
+ keys = ["uuid", "_id", "id"],
+ keymatchtype,
+ index
+) => {
+ if (typeof option === "object") {
+ obj = true
+ }
+ if (!obj && list && list.indexOf && list.indexOf(option) >= 0) {
+ return index ? list.indexOf(option) : true
+ } else if (obj && list && typeof list.length == "number") {
+ for (let i = 0; i < list.length; i++) {
+ if (!(keys && typeof keys.length == "number")) return
+ for (let indKey = 0; indKey < keys.length; indKey++) {
+ if (keymatchtype == "broad") {
+ if (
+ list[i] &&
+ getsmart.bind(this)(list[i], keys[indKey], undefined) ==
+ getsmart.bind(this)(option, keys[indKey], undefined) &&
+ getsmart.bind(this)(list[i], keys[indKey], undefined) !== undefined
+ ) {
+ return index ? i : true
+ } else if (
+ list[i] &&
+ typeof list[i] == "string" &&
+ list[i] == getsmart.bind(this)(option, keys[indKey], undefined) &&
+ getsmart.bind(this)(option, keys[indKey], undefined) !== undefined
+ ) {
+ return index ? i : true
+ }
+ } else {
+ if (
+ list[i] &&
+ getsmart.bind(this)(list[i], keys[indKey], undefined) ==
+ getsmart.bind(this)(option, keys[indKey], undefined) &&
+ getsmart.bind(this)(list[i], keys[indKey], undefined) !== undefined
+ ) {
+ if (indKey == keys.length - 1) {
+ return index ? i : true
+ }
+ } else if (
+ list[i] &&
+ typeof list[i] == "string" &&
+ list[i] == getsmart.bind(this)(option, keys[indKey], undefined) &&
+ getsmart.bind(this)(option, keys[indKey], undefined) !== undefined
+ ) {
+ if (indKey == keys.length - 1) {
+ return index ? i : true
+ }
+ }
+ }
+ }
+ }
+ }
+ return index ? -1 : false
+}
+export const thingIn = ({
+ option,
+ list = getsmart.bind(this)(objList),
+ obj = true,
+ keys = ["uuid", "_id", "id"],
+ keymatchtype,
+ retIndex,
+ // vue = local.vue
+} = {}) => {
+ if (typeof option === "object") {
+ obj = true
+ }
+ if (!obj && list && list.indexOf && list.indexOf(option) >= 0) {
+ if (retIndex) {
+ return list.indexOf(option)
+ } else {
+ return true
+ }
+ } else if (obj && list && typeof list.length == "number") {
+ for (let i = 0; i < list.length; i++) {
+ if (!(keys && typeof keys.length == "number")) return
+ for (let indKey = 0; indKey < keys.length; indKey++) {
+ if (keymatchtype == "broad") {
+ if (
+ list[i] &&
+ getsmart.bind(this)(list[i], keys[indKey], undefined) ==
+ getsmart.bind(this)(option, keys[indKey], undefined) &&
+ getsmart.bind(this)(list[i], keys[indKey], undefined) !== undefined
+ ) {
+ if (retIndex) {
+ return i
+ } else {
+ return true
+ }
+ } else if (
+ list[i] &&
+ typeof list[i] == "string" &&
+ list[i] == getsmart.bind(this)(option, keys[indKey], undefined) &&
+ getsmart.bind(this)(option, keys[indKey], undefined) !== undefined
+ ) {
+ if (retIndex) {
+ return i
+ } else {
+ return true
+ }
+ }
+ } else {
+ if (
+ list[i] &&
+ getsmart.bind(this)(list[i], keys[indKey], undefined) ==
+ getsmart.bind(this)(option, keys[indKey], undefined) &&
+ getsmart.bind(this)(list[i], keys[indKey], undefined) !== undefined
+ ) {
+ if (indKey == keys.length - 1) {
+ if (retIndex) {
+ return i
+ } else {
+ return true
+ }
+ }
+ } else if (
+ list[i] &&
+ typeof list[i] == "string" &&
+ list[i] == getsmart.bind(this)(option, keys[indKey], undefined) &&
+ getsmart.bind(this)(option, keys[indKey], undefined) !== undefined
+ ) {
+ if (indKey == keys.length - 1) {
+ if (retIndex) {
+ return i
+ } else {
+ return true
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (retIndex) {
+ return -1
+ } else {
+ return false
+ }
+}
+export const optsIn = (
+ options,
+ list = getsmart.bind(this)(stringList),
+ obj,
+ keys = ["uuid", "_id", "id"],
+ keymatchtype
+) => {
+ if (!(options instanceof Array)) return true
+ for (const option of options) {
+ // if(typeof option === 'object'){
+ // obj = true
+ // }
+ if (!obj && list && list.indexOf && list.indexOf(option) >= 0) {
+ // return true
+ } else if (obj && list) {
+ for (let i = 0; i < list.length; i++) {
+ if (!optIn(option, list[i], obj, keys, keymatchtype)) {
+ return false
+ }
+ }
+ } else {
+ return false
+ }
+ }
+ return true
+}
+export const thingsIn = ({
+ options,
+ list = getsmart.bind(this)(stringList),
+ obj,
+ keys = ["uuid", "_id", "id"],
+ keymatchtype,
+} = {}) => {
+ if (!(options instanceof Array)) return true
+ for (const option of options) {
+ // if(typeof option === 'object'){
+ // obj = true
+ // }
+ if (!obj && list && list.indexOf && list.indexOf(option) >= 0) {
+ // return true
+ } else if (obj && list && typeof list.length == "number") {
+ for (let i = 0; i < list.length; i++) {
+ if (!optIn(option, list[i], obj, keys, keymatchtype)) {
+ return false
+ }
+ }
+ } else {
+ return false
+ }
+ }
+ return true
+}
+export const anyOptsIn = (
+ options,
+ list = getsmart.bind(this)(stringList),
+ obj,
+ keys = ["uuid", "_id", "id"],
+ keymatchtype
+) => {
+ if (!(options instanceof Array)) return false
+ for (const option of options) {
+ // if(typeof option === 'object'){
+ // obj = true
+ // }
+ if (!obj && list && list.indexOf && list.indexOf(option) >= 0) {
+ return true
+ } else if (obj && list && typeof list.length == "number") {
+ for (let i = 0; i < list.length; i++) {
+ if (optIn(option, list[i], obj, keys, keymatchtype)) {
+ return true
+ }
+ }
+ }
+ }
+ return false
+}
+export const anyThingsIn = ({
+ options,
+ list = getsmart.bind(this)(stringList),
+ obj,
+ keys = ["uuid", "_id", "id"],
+ keymatchtype,
+} = {}) => {
+ if (!(options instanceof Array)) return false
+ for (const option of options) {
+ // if(typeof option === 'object'){
+ // obj = true
+ // }
+ if (!obj && list && list.indexOf && list.indexOf(option) >= 0) {
+ return true
+ } else if (obj && list && typeof list.length == "number") {
+ for (let i = 0; i < list.length; i++) {
+ if (optIn(option, list[i], obj, keys, keymatchtype)) {
+ return true
+ }
+ }
+ }
+ }
+ return false
+}
+export const optIndex = (
+ option,
+ list = getsmart.bind(this)(stringList),
+ obj,
+ keys = ["uuid", "_id", "id"],
+ keymatchtype
+) => {
+ if (typeof option === "object") {
+ obj = true
+ }
+ if (obj && list && keys && typeof list.length == "number") {
+ for (let i = 0; i < list.length; i++) {
+ if (optIn(option, list, obj, keys, keymatchtype)) {
+ return i
+ }
+ }
+ } else if (list) {
+ return list.indexOf(option)
+ }
+ return -1
+}
+export const thingIndex = ({
+ option,
+ list,
+ obj,
+ keys = ["uuid", "_id", "id"],
+ keymatchtype,
+ strings,
+} = {}) => {
+ if (typeof option === "object") {
+ obj = true
+ }
+ if (obj && list && keys) {
+ const index = thingIn({
+ option,
+ list,
+ obj,
+ keys,
+ keymatchtype,
+ strings,
+ retIndex: true,
+ })
+ return index
+ } else if (list) {
+ return list.indexOf(option)
+ }
+ return -1
+}
+export const pushOpt = (
+ option,
+ list = getsmart.bind(this)(stringList),
+ obj,
+ keys = ["uuid", "_id", "id"],
+ keymatchtype,
+ index
+) => {
+ if (
+ typeof list == "object" &&
+ !optIn(option, list, obj, keys, keymatchtype)
+ ) {
+ if (
+ getsmart.bind(this)(local.vue, "reactiveSetter", false) ||
+ getsmart.bind(this)(local.vue, "store", false)
+ ) {
+ list.splice(list.length, 0, option)
+ if (
+ !localStorage.getItem("vuexWriteLock") &&
+ typeof getsmart.bind(this)(window, "$store.commit", undefined) ==
+ "function"
+ ) {
+ window.$store.commit(local.vue.basePath || "graph/thing")
+ }
+ } else {
+ list.push(option)
+ }
+ }
+ return index
+ ? optIn(option, list, obj, keys, keymatchtype, index)
+ : optIn(option, list, obj, keys, keymatchtype, index)
+}
+export const addOpt = (
+ option,
+ list = getsmart.bind(this)(stringList),
+ obj,
+ keys = ["uuid", "_id", "id"],
+ keymatchtype,
+ index
+) => {
+ if (typeof list == "object") {
+ if (
+ getsmart.bind(this)(local.vue, "reactiveSetter", false) ||
+ getsmart.bind(this)(local.vue, "store", false)
+ ) {
+ list.splice(list.length, 0, option)
+ if (
+ !localStorage.getItem("vuexWriteLock") &&
+ typeof getsmart.bind(this)(window, "$store.commit", undefined) ==
+ "function"
+ ) {
+ window.$store.commit(local.vue.basePath || "graph/thing")
+ }
+ } else {
+ list.push(option)
+ }
+ }
+ return index
+ ? optIn(option, list, obj, keys, keymatchtype, index)
+ : optIn(option, list, obj, keys, keymatchtype, index)
+}
+export const pushThing = ({
+ option,
+ list = getsmart.bind(this)(stringList),
+ obj,
+ keys = ["uuid", "_id", "id"],
+ keymatchtype,
+} = {}) => {
+ if (
+ typeof list == "object" &&
+ !thingIn({ option, list, obj, keys, keymatchtype })
+ ) {
+ if (
+ getsmart.bind(this)(local.vue, "reactiveSetter", false) ||
+ getsmart.bind(this)(local.vue, "store", false)
+ ) {
+ list.splice(list.length, 0, option)
+ if (
+ !localStorage.getItem("vuexWriteLock") &&
+ typeof getsmart.bind(this)(window, "$store.commit", undefined) ==
+ "function"
+ ) {
+ window.$store.commit(local.vue.basePath || "graph/thing")
+ }
+ } else {
+ list.push(option)
+ }
+ }
+}
+export const pushOpts = (
+ options,
+ list = getsmart.bind(this)(stringList),
+ obj,
+ keys = ["uuid", "_id", "id"],
+ keymatchtype
+) => {
+ if (!(options instanceof Array)) return
+ for (const option of options) {
+ pushOpt(option, list, obj, keys, keymatchtype)
+ }
+}
+export const pushThings = ({
+ options,
+ list = getsmart.bind(this)(stringList),
+ obj,
+ keys = ["uuid", "_id", "id"],
+ keymatchtype,
+} = {}) => {
+ if (!(options instanceof Array)) return
+ for (const option of options) {
+ pushThing({ option, list, obj, keys, keymatchtype })
+ }
+}
+export const popOpt = (
+ option,
+ list = getsmart.bind(this)(stringList),
+ obj,
+ keys = ["uuid", "_id", "id"],
+ keymatchtype
+) => {
+ if (typeof list == "object" && optIn(option, list, obj, keys, keymatchtype)) {
+ list.splice(optIndex(option, list, obj, keys, keymatchtype), 1)
+ if (
+ getsmart.bind(this)(local.vue, "reactiveSetter", false) ||
+ getsmart.bind(this)(local.vue, "store", false)
+ ) {
+ if (
+ !localStorage.getItem("vuexWriteLock") &&
+ typeof getsmart.bind(this)(window, "$store.commit", undefined) ==
+ "function"
+ ) {
+ window.$store.commit(local.vue.basePath || "graph/thing")
+ }
+ }
+ }
+}
+export const popThing = ({
+ option,
+ list = getsmart.bind(this)(stringList),
+ obj = true,
+ keys = ["uuid", "_id", "id"],
+ keymatchtype,
+} = {}) => {
+ if (
+ typeof list == "object" &&
+ thingIn({
+ option,
+ list,
+ obj,
+ keys,
+ keymatchtype,
+ })
+ ) {
+ list.splice(
+ thingIndex({
+ option,
+ list,
+ obj,
+ keys,
+ keymatchtype,
+ }),
+ 1
+ )
+ if (
+ getsmart.bind(this)(local.vue, "reactiveSetter", false) ||
+ getsmart.bind(this)(local.vue, "store", false)
+ ) {
+ if (
+ !localStorage.getItem("vuexWriteLock") &&
+ typeof getsmart.bind(this)(window, "$store.commit", undefined) ==
+ "function"
+ ) {
+ window.$store.commit(local.vue.basePath || "graph/thing")
+ }
+ }
+ }
+}
+export const popOpts = (
+ options,
+ list = getsmart.bind(this)(stringList),
+ obj,
+ keys = ["uuid", "_id", "id"],
+ keymatchtype
+) => {
+ if (!(options instanceof Array)) return
+ for (const option of options) {
+ popOpt(option, list, obj, keys, keymatchtype)
+ }
+}
+export const popThings = ({
+ options,
+ list = getsmart.bind(this)(stringList),
+ obj = true,
+ keys = ["uuid", "_id", "id"],
+ keymatchtype,
+} = {}) => {
+ if (!(options instanceof Array)) return
+ for (const option of options) {
+ popOpt(option, list, obj, keys, keymatchtype)
+ }
+}
+export const toggleOpt = (
+ option,
+ list = getsmart.bind(this)(stringList),
+ obj,
+ keys = ["uuid", "_id", "id"],
+ keymatchtype
+) => {
+ if (optIn(option, list, obj, keys, keymatchtype)) {
+ popOpt(option, list, obj, keys, keymatchtype)
+ } else {
+ pushOpt(option, list, obj, keys, keymatchtype)
+ }
+}
+export const toggleThing = ({
+ option,
+ list = getsmart.bind(this)(stringList),
+ obj = true,
+ keys = ["uuid", "_id", "id"],
+ keymatchtype,
+} = {}) => {
+ if (optIn(option, list, obj, keys, keymatchtype)) {
+ popOpt(option, list, obj, keys, keymatchtype)
+ } else {
+ pushOpt(option, list, obj, keys, keymatchtype)
+ }
+}
+export const toggleOpts = (
+ options,
+ list = getsmart.bind(this)(stringList),
+ obj,
+ keys = ["uuid", "_id", "id"],
+ keymatchtype
+) => {
+ if (!(options instanceof Array)) return
+ for (const option in options) {
+ toggleOpt(option, list, obj, keys, keymatchtype)
+ }
+}
+export const toggleThings = ({
+ options,
+ list = getsmart.bind(this)(stringList),
+ obj = true,
+ keys = ["uuid", "_id", "id"],
+ keymatchtype,
+} = {}) => {
+ if (!(options instanceof Array)) return
+ for (const option in options) {
+ if (optIn(option, list, obj, keys, keymatchtype)) {
+ popOpt(option, list, obj, keys, keymatchtype)
+ } else {
+ pushOpt(option, list, obj, keys, keymatchtype)
+ }
+ }
+}
+// no use right now
+// export const ratchetOpt = (
+// option,
+// list,
+// obj,
+// keys = ['uuid', '_id', 'id'],
+// keymatchtype
+// ) => {
+// // find(obj, property, equals){
+// // if(getsmart.bind(this)(obj, 'constructor', undefined) == Array){
+// // for(var i=0; i {
+ if (!property && obj && typeof obj == "string") {
+ property = obj.split(".")
+ try {
+ obj = eval(property[0])
+ } catch (err) {
+ // console.error(err)
+
+ obj = property[0]
+ }
+ property = property.slice(1, property.length)
+ }
+ if (!property) {
+ if (context) {
+ return {
+ value: defaultValue,
+ undefined: true,
+ }
+ } else {
+ return defaultValue
+ }
+ }
+ // If the property list is in dot notation, convert to array
+ if (typeof property == "string") {
+ property = parsePropertyPath(property)
+ } else if (getsmart.bind(this)(property, "constructor", false) !== Array) {
+ if (context) {
+ return {
+ value: defaultValue,
+ undefined: true,
+ err: "properties path @property argument was not passed properly",
+ }
+ } else {
+ return defaultValue
+ }
+ }
+
+ const deepGetByArray = deepGetByArrayUnbound.bind(this)
+
+ return deepGetByArray(obj, property, defaultValue)
+
+ // In order to avoid constantly checking the type of the property
+ // we separate the real logic out into an inner function.
+ function deepGetByArrayUnbound(obj, propsArray, defaultValue) {
+ // This case getting to the last property but it not being ultimately defined
+ // Not just having a value of undefined
+ if (
+ propsArray.length > 0 &&
+ context &&
+ typeof obj == "object" &&
+ obj !== null &&
+ !(ee(propsArray[0]) in obj)
+ ) {
+ return {
+ value: defaultValue,
+ undefined: true,
+ }
+ }
+
+ // If we have reached an undefined/null property
+ // then stop executing and return the default value.
+ // If no default was provided it will be undefined.
+ if (
+ typeof obj == "undefined" ||
+ obj == null ||
+ (schema && obj.constructor.name !== schema)
+ ) {
+ if (context) {
+ let undef = true
+ if (propsArray.length === 0) {
+ undef = false
+ }
+ return {
+ value: defaultValue,
+ undefined: undef,
+ schema: schema && obj.constructor.name === schema,
+ }
+ } else {
+ return defaultValue
+ }
+ } // If the path array has no more elements, we've reached
+ // the intended property and return its value
+
+ if (propsArray.length === 0) {
+ if (context) {
+ return {
+ value: obj,
+ undefined: false,
+ }
+ } else {
+ return obj
+ }
+ } // Prepare our found property and path array for recursion
+
+ const nextObj = obj[ee(propsArray[0])]
+ const remainingProps = propsArray.slice(1)
+ return deepGetByArray(nextObj, remainingProps, defaultValue)
+ }
+}
+export const escapePropertyPath = (path = "") => {
+ const newPath = escapeEscapes(path)
+ return '["' + newPath + '"]'
+}
+export const epp = (path = "") => {
+ return escapePropertyPath(path)
+}
+export const escapeEscapes = (path = "") => {
+ let newPath = ""
+ for (let i in path) {
+ i = +i
+ const char = path[i]
+ if (i > 0 && i < path.length - 1) {
+ const prevChar = path[i - 1]
+ const nextChar = path[i + 1]
+ const openingArrayPath = char === '"' && prevChar === "["
+ // && (nextChar !== "\\" || i === path.length-1)
+ const closingArrayPath =
+ char === '"' && nextChar === "]" && prevChar !== "\\"
+ // let offset = 0
+ // if(openingArrayPath) offset = 1
+ if (openingArrayPath || closingArrayPath) {
+ newPath += "\\"
+ // path = path.slice(0,i+offset)+"\\"+path.slice(i+offset,path.length)
+ }
+ }
+ newPath += char
+ }
+ return newPath
+}
+export const ee = (path = "") => {
+ return escapeEscapes(path)
+}
+// TODO
+// Make parsing use \" or \'
+// Currently only uses \"
+export const parsePropertyPath = (path = "") => {
+ const array = []
+
+ let readingArrayBasedPath = false
+ let i = 0
+ let push = false
+ let pushed = false
+ while (i < path.length) {
+ const arrayPathStart = path[i] == "[" && path[i + 1] == '"'
+ const escapedStart = !(path[i + 1] !== "\\" || i === 0)
+
+ if (readingArrayBasedPath) {
+ // we found the end of an array delimited path
+ const arrayPathEnd = path[i] == '"' && path[i + 1] == "]"
+ const escapedEnd = !(path[i - 1] !== "\\" || i == 0)
+ if (arrayPathEnd && !escapedEnd) {
+ i += 1
+ readingArrayBasedPath = false
+ if (!pushed) push = true
+ } else {
+ // if the path includes an "escaped" array based path begin or end value
+ // do not push the escape character
+ if (
+ (path[i] == "\\" && path[i + 1] == '"' && path[i + 2] == "]") ||
+ (path[i - 1] == "[" && path[i] == "\\" && path[i + 1] == '"')
+ ) {
+ // nothing
+ } else {
+ array[array.length - 1] += path[i]
+ }
+ }
+ } else if (path[i] == ".") {
+ if (!pushed) push = true
+ }
+ // we found the start of an array delimited path
+ else if (arrayPathStart && !escapedStart) {
+ readingArrayBasedPath = true
+ if (!pushed) push = true
+ i += 1
+ } else {
+ if (i == 0) array.push("")
+ array[array.length - 1] += path[i]
+ }
+
+ i++
+ if (push && i < path.length) {
+ pushed = true
+ array.push("")
+ push = false
+ } else {
+ pushed = false
+ }
+ }
+
+ return array
+}
+export const ppp = (path = "") => {
+ return this.parsePropertyPath(path)
+}
+export const parsePropertyArray = (pathArray) => {
+ let path = ""
+
+ if (pathArray instanceof Array) {
+ pathArray.forEach((subPath) => {
+ path += epp(subPath)
+ })
+ } else if (typeof pathArray === "string") {
+ return path
+ }
+
+ return path
+}
+export const ppa = (pathArray) => {
+ return this.parsePropertyArray(pathArray)
+}
+export const pathToArray = (path) => {
+ if (typeof path == "string") {
+ return parsePropertyPath(path)
+ } else {
+ return path
+ }
+}
+export const pathToString = (path) => {
+ if (typeof path == "string") {
+ let ret = parsePropertyPath(path)
+ ret = parsePropertyArray(ret)
+ return ret
+ } else {
+ const ret = parsePropertyArray(path)
+ return ret
+ }
+}
+export const setsmart = (obj, property, value, context?: any) => {
+ if (!property && typeof obj == "string") {
+ property = obj.split(".")
+ try {
+ obj = eval(property[0])
+ } catch (err) {
+ obj = property[0]
+ }
+ property = property.slice(1, property.length)
+ }
+ // If the property list is in dot notation, convert to array
+ if (typeof property == "string") {
+ property = parsePropertyPath(property)
+ } else if (getsmart.bind(this)(property, "constructor", false) !== Array) {
+ if (context) {
+ return {
+ value: value,
+ undefined: true,
+ err: "properties path @property argument was not passed properly",
+ }
+ } else {
+ return value
+ }
+ }
+
+ // if no obj make obj
+ if (!obj || (typeof obj !== "object" && typeof obj !== "function")) obj = {}
+
+ const deepSetByArray = deepSetByArrayUnbound.bind(this)
+
+ if (property) {
+ return deepSetByArray(obj, property, value)
+ } else {
+ if (
+ getsmart.bind(this)(local.vue, "reactiveSetter", false) &&
+ getsmart.bind(this)(
+ this,
+ "$set",
+ getsmart.bind(this)(local.vue, "Vue.set", false)
+ ) &&
+ obj
+ ) {
+ const setToUse = this.$set || local.vue.Vue.set
+ setToUse(obj, undefined, value)
+ if (
+ typeof getsmart.bind(this)(window, "$store.commit", undefined) ==
+ "function"
+ ) {
+ window.$store.commit(local.vue.basePath || "graph/thing")
+ }
+ } else {
+ obj = value
+ if (
+ getsmart.bind(this)(local.vue, "store", false) &&
+ typeof getsmart.bind(this)(window, "$store.commit", undefined) ==
+ "function"
+ ) {
+ window.$store.commit(local.vue.basePath || "graph/thing")
+ }
+ }
+ if (context) {
+ return {
+ value: obj,
+ undefined: false,
+ err: "there were no properties passed",
+ }
+ } else {
+ return obj
+ }
+ }
+
+ // In order to avoid constantly checking the type of the property
+ // we separate the real logic out into an inner function.
+ function deepSetByArrayUnbound(obj, propsArray, value) {
+ // If the path array has only 1 more element, we've reached
+ // the intended property and set its value
+ if (propsArray.length == 1) {
+ if (
+ getsmart.bind(this)(local.vue, "reactiveSetter", false) &&
+ getsmart.bind(this)(
+ this,
+ "$set",
+ getsmart.bind(this)(local.vue, "Vue.set", false)
+ ) &&
+ obj
+ ) {
+ const setToUse = this.$set || local.vue.Vue.set
+ setToUse(obj, ee(propsArray[0]), value)
+ if (
+ typeof getsmart.bind(this)(window, "$store.commit", undefined) ==
+ "function"
+ ) {
+ window.$store.commit(local.vue.basePath || "graph/thing")
+ }
+ } else {
+ // TODO: make parent object new object so that react can see the change
+ obj[ee(propsArray[0])] = value
+ if (
+ getsmart.bind(this)(local.vue, "store", false) &&
+ typeof getsmart.bind(this)(window, "$store.commit", undefined) ==
+ "function"
+ ) {
+ window.$store.commit(local.vue.basePath || "graph/thing")
+ }
+ }
+ if (context) {
+ return {
+ value: obj[ee(propsArray[0])],
+ undefined: false,
+ }
+ } else {
+ return obj[ee(propsArray[0])]
+ }
+ }
+ // Prepare our path array for recursion
+ const remainingProps = propsArray.slice(1)
+ // check if next prop is object
+ if (typeof obj[ee(propsArray[0])] !== "object") {
+ // If we have reached an undefined/null property
+ if (
+ getsmart.bind(this)(local.vue, "reactiveSetter", false) &&
+ getsmart.bind(this)(
+ this,
+ "$set",
+ getsmart.bind(this)(local.vue, "Vue.set", false)
+ ) &&
+ obj
+ ) {
+ const setToUse = this.$set || local.vue.Vue.set
+ setToUse(obj, ee(propsArray[0]), {})
+ if (
+ typeof getsmart.bind(this)(window, "$store.commit", undefined) ==
+ "function"
+ ) {
+ window.$store.commit(local.vue.basePath || "graph/thing")
+ }
+ } else {
+ obj[ee(propsArray[0])] = {}
+ if (
+ getsmart.bind(this)(local.vue, "store", false) &&
+ typeof getsmart.bind(this)(window, "$store.commit", undefined) ==
+ "function"
+ ) {
+ window.$store.commit(local.vue.basePath || "graph/thing")
+ }
+ }
+ }
+ return deepSetByArray(obj[ee(propsArray[0])], remainingProps, value)
+ }
+}
+export const deletesmart = (obj, property) => {
+ if (!property && typeof obj == "string") {
+ property = obj.split(".")
+ try {
+ obj = eval(property[0])
+ } catch (err) {
+ // console.error(err)
+ obj = property[0]
+ }
+ property = property.slice(1, property.length)
+ }
+ // If the property list is in dot notation, convert to array
+ if (typeof property == "string") {
+ property = parsePropertyPath(property)
+ }
+ const parentPathArray = property.slice(0, property.length - 1)
+ const path = property[property.length - 1]
+ const parentObj = getsmart(obj, parentPathArray, {})
+
+ if (
+ getsmart.bind(this)(local.vue, "reactiveSetter", false) &&
+ getsmart.bind(this)(
+ this,
+ "$set",
+ getsmart.bind(this)(local.vue, "Vue.set", false)
+ ) &&
+ obj
+ ) {
+ this.$delete(parentObj, path)
+ } else {
+ delete parentObj[path]
+ }
+}
+export const pushSmart = (array, value) => {
+ if (
+ getsmart.bind(this)(local.vue, "reactiveSetter", false) &&
+ getsmart.bind(this)(
+ this,
+ "$set",
+ getsmart.bind(this)(local.vue, "Vue.set", false)
+ ) &&
+ array
+ ) {
+ array.push(value)
+ if (
+ typeof getsmart.bind(this)(window, "$store.commit", undefined) ==
+ "function"
+ ) {
+ window.$store.commit(local.vue.basePath || "graph/thing")
+ }
+ } else {
+ array.push(value)
+ }
+}
+export const gosmart = (obj, property, value, context, schema) => {
+ // stands for get or set smart
+ let get = getsmart.bind(this)(
+ obj,
+ property,
+ value,
+ true,
+ schema ? absoluteType.bind(this)(value) : false
+ )
+ if (get.undefined || (schema && get.schema === false)) {
+ get = setsmart.bind(this)(obj, property, get.value, context)
+ if (context) {
+ return get
+ } else {
+ return get
+ }
+ } else {
+ return get.value
+ }
+}
+export const gosmarter = (obj, property, value, context, schema = true) => {
+ return gosmart.bind(this)(obj, property, value, context, schema)
+}
+export const absoluteType = (value) => {
+ let type
+ try {
+ type = value.constructor.name
+ } catch (e) {
+ if (typeof value === "undefined") type = "undefined"
+ if (value === null) type = "null"
+ }
+ return type
+}
+export const vgosmart = (obj, property, value, context) => {
+ // stands for v-model get or set smart
+ // return value from property path, either gotten or smartly set
+ return {
+ get: () => {
+ let get = getsmart.bind(this)(obj, property, value, true)
+ if (get.undefined) {
+ get = setsmart.bind(this)(obj, property, get.value, context)
+ }
+ if (context) {
+ return get
+ } else {
+ return getsmart.bind(this)(get, "value", get)
+ }
+ },
+ set: (val) => {
+ setsmart.bind(this)(obj, property, val)
+ },
+ }
+}
+export const getsmartval = (obj, property, defaultValue) => {
+ // get the value of a property path based off its type
+ const target = getsmart.bind(this)(obj, property, defaultValue)
+ if (target && target.type) {
+ if (target[target.type]) {
+ return target[target.type]
+ } else {
+ return defaultValue
+ }
+ } else if (target) {
+ return target
+ }
+ return defaultValue
+}
+export const safestring = (something) => {
+ return smarts.stringify(something || "")
+}
+export const safeparse = (something) => {
+ return smarts.parse(something || "")
+}
+export const flatten = (arrays, func = (i) => i) => {
+ const flat = []
+
+ arrays.forEach((array) => {
+ if (Array.isArray(array)) {
+ flat.push(...flatten(array))
+ } else {
+ flat.push(func(array))
+ }
+ })
+
+ return flat
+}
+export const mapsmart = (list, keyProperty = "title", returnExistant) => {
+ return new Promise((resolve, reject) => {
+ if (!keyProperty) {
+ reject()
+ } else if (list && typeof list.length == "number") {
+ if (list.length == 0) {
+ if (
+ (returnExistant &&
+ getsmart.bind(this)(list, "mapped." + returnExistant, false)) ||
+ !returnExistant
+ ) {
+ resolve(true)
+ } else if (returnExistant) {
+ resolve(false)
+ } else {
+ resolve()
+ }
+ }
+ if (!list.mapped || typeof list.mapped === "boolean") {
+ if (
+ getsmart.bind(this)(local.vue, "reactiveSetter", false) &&
+ getsmart.bind(this)(
+ this,
+ "$set",
+ getsmart.bind(this)(local.vue, "Vue.set", false)
+ ) &&
+ list
+ ) {
+ const setToUse = this.$set || local.vue.Vue.set
+ setToUse(list, "mapped", {})
+ } else {
+ list["mapped"] = {}
+ }
+ }
+ for (let i = 0; i < list.length; i++) {
+ if (typeof list[i] !== "string") {
+ if (
+ getsmart.bind(this)(local.vue, "reactiveSetter", false) &&
+ getsmart.bind(this)(
+ this,
+ "$set",
+ getsmart.bind(this)(local.vue, "Vue.set", false)
+ ) &&
+ list.mapped
+ ) {
+ const setToUse = this.$set || local.vue.Vue.set
+ setToUse(list.mapped, list[i][keyProperty], list[i])
+ } else {
+ list["mapped"][list[i][keyProperty]] = list[i]
+ }
+ if (i == list.length - 1) {
+ if (
+ (returnExistant &&
+ getsmart.bind(this)(list, "mapped." + returnExistant, false)) ||
+ !returnExistant
+ ) {
+ resolve(true)
+ } else if (returnExistant) {
+ resolve(false)
+ } else {
+ resolve()
+ }
+ }
+ }
+ // else if(populate){
+ // var funCounter = this.funCounter
+ // this.funCounter = this.funCounter + 1
+ // getThing({
+ // thing: list[i],
+ // clientId: this._uid,
+ // funCounter
+ // })
+ // this.$options.sockets['giveThing'] = data => {
+ // if(this._uid == data.clientId && data.funCounter == funCounter){
+ // (this.$set || local.vue.Vue.set)(list, i.toString(), data.thing)
+ // (this.$set || local.vue.Vue.set)(list.mapped, list[i][keyProperty], list[i])
+ // }
+ // if(i==list.length-1){
+ // if((returnExistant && getsmart.bind(this)(list, 'mapped.'+returnExistant, false)) || !returnExistant){
+ // resolve(true)
+ // } else if(returnExistant) {
+ // resolve(false)
+ // } else {
+ // resolve()
+ // }
+ // }
+ // }
+ // }
+ else if (i == list.length - 1) {
+ if (
+ (returnExistant &&
+ getsmart.bind(this)(list, "mapped." + returnExistant, false)) ||
+ !returnExistant
+ ) {
+ resolve(true)
+ } else if (returnExistant) {
+ resolve(false)
+ } else {
+ resolve()
+ }
+ }
+ }
+ // if(list.mapped && !list.mapped['agora-client-mapped']){
+ // (this.$set || local.vue.Vue.set)(list.mapped, 'agora-client-mapped', true)
+ // }
+ }
+ })
+}
+export const domval = (thing) => {
+ return getsmart.bind(this)(thing, "properties.description", "")
+}
+export const getParent = (levels = Infinity) => {
+ if (typeof levels == "string") levels = (levels.match(/\.\./g) || []).length
+
+ if (levels >= this.pathAsArray.length - 1) {
+ return this.pathAsArray[0]
+ }
+
+ const level = this.pathAsArray.length - 1 - levels
+
+ return this.pathAsArray[level]
+}
+export const getThing = (props = {}) => {
+ const { list = getsmart.bind(this)(objList), defaultValue = undefined } =
+ props
+
+ const index = thingIn({
+ ...props,
+ retIndex: true,
+ })
+ if (index >= 0) {
+ return list[index]
+ } else {
+ return defaultValue
+ }
+}
+export const equal = (obj1, obj2, seen = []) => {
+ if (obj1 && obj2 && typeof obj1 == "object" && typeof obj2 == "object") {
+ seen.push(obj1, obj2)
+ //Loop through properties in object 1
+ for (const p in obj1) {
+ //Check property exists on both objects
+ if (
+ typeof obj1.hasOwnProperty == "function" &&
+ typeof obj2.hasOwnProperty == "function" &&
+ Object.prototype.hasOwnProperty.call(obj1, p) !==
+ Object.prototype.hasOwnProperty.call(obj2, p)
+ )
+ return false
+
+ switch (typeof obj1[p]) {
+ //Deep compare objects
+ case "object":
+ if (seen.indexOf(obj1[p]) < 0 && !equal(obj1[p], obj2[p], seen))
+ return false
+ break
+ //Compare function code
+ case "function":
+ if (
+ typeof obj2[p] == "undefined" ||
+ obj1[p].toString() != obj2[p].toString()
+ )
+ return false
+ break
+ //Compare values
+ default:
+ if (obj1[p] != obj2[p]) return false
+ }
+ }
+
+ //Check object 2 for any extra properties
+ for (const p in obj2) {
+ if (!(p in obj1)) return false
+ }
+ return true
+ }
+}
+export const mergeall = (array, options) => {
+ if (!Array.isArray(array)) {
+ throw new Error("first argument should be an array")
+ }
+
+ return array.reduce(function (prev, next) {
+ return merge(prev, next, options)
+ }, {})
+}
+
+// export const smarts with all other exports
+export const smarts = {
+ local,
+ t,
+ getBabel,
+ uuid,
+ pause,
+ save,
+ toJavascript,
+ toJavascriptAux,
+ createObjectProperties,
+ serialize,
+ stringify,
+ replacer,
+ setKnown,
+ stringifier,
+ primitives,
+ Primitives,
+ play,
+ load,
+ parse,
+ parser,
+ revive,
+ createScopedEval,
+ defineVariable,
+ scopedEval,
+ jsUUID,
+ context,
+ contextObject,
+ createContext,
+ createInlineContext,
+ addBindingsToContext,
+ scopeVarCode,
+ scopeVarInlineCode,
+ scopeVar,
+ functionWrapper,
+ bodyInsert,
+ initBlock,
+ getNodeUUID,
+ getPathUUID,
+ babelPlugin,
+ transform,
+ stripUuids,
+ dupe,
+ clone,
+ schema,
+ create,
+ merge,
+ basic,
+ mod,
+ deepForEach,
+ forEachObject,
+ forEachArray,
+ setThing,
+ setThings,
+ optIn,
+ thingIn,
+ optsIn,
+ thingsIn,
+ anyOptsIn,
+ anyThingsIn,
+ optIndex,
+ thingIndex,
+ pushOpt,
+ addOpt,
+ pushThing,
+ pushOpts,
+ pushThings,
+ popOpt,
+ popThing,
+ popOpts,
+ popThings,
+ toggleOpt,
+ toggleThing,
+ toggleOpts,
+ toggleThings,
+ // ratchetOpt,
+ getsmart,
+ escapePropertyPath,
+ epp,
+ escapeEscapes,
+ ee,
+ parsePropertyPath,
+ ppp,
+ parsePropertyArray,
+ ppa,
+ pathToArray,
+ pathToString,
+ setsmart,
+ deletesmart,
+ pushSmart,
+ gosmart,
+ gosmarter,
+ absoluteType,
+ vgosmart,
+ getsmartval,
+ safestring,
+ safeparse,
+ flatten,
+ mapsmart,
+ domval,
+ getParent,
+ getThing,
+ equal,
+ mergeall,
+}
diff --git a/app/tsconfig.json b/remix/tsconfig.json
similarity index 100%
rename from app/tsconfig.json
rename to remix/tsconfig.json
diff --git a/remix/vercel.json b/remix/vercel.json
new file mode 100644
index 0000000..dcfba92
--- /dev/null
+++ b/remix/vercel.json
@@ -0,0 +1,7 @@
+{
+ "build": {
+ "env": {
+ "ENABLE_FILE_SYSTEM_API": "1"
+ }
+ }
+}
diff --git a/app/vite.config.ts b/remix/vite.config.ts
similarity index 100%
rename from app/vite.config.ts
rename to remix/vite.config.ts