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 local = {}
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)
}
export const toJavascript = (value, opts = {}) => {
let 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 (let declaration of opts.declarations) {
if (declaration.type === 'ExpressionStatement') {
// nothing
} else {
let key = declaration.declarations[0].id.name
let dependancies = opts.dependancies[key]
let dependancyCheck = {}
for (let dependancy of dependancies) {
dependancyCheck[dependancy] = false
}
let sortableDeclarationIndex = 0
let insertionIndex = 0
for (let sortableDeclaration of opts.declarations) {
if (sortableDeclaration.type === 'ExpressionStatement') {
// nothing
} else {
let sortableDeclarationKey =
sortableDeclaration.declarations[0].id.name
if (dependancyCheck[sortableDeclarationKey] === false) {
insertionIndex = sortableDeclarationIndex + 1
dependancyCheck[sortableDeclarationKey] = true
}
}
// increment iterator index
sortableDeclarationIndex++
}
let 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')))
let 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)
}
let 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)
let properties = createObjectProperties(value, opts)
let declaration = t.variableDeclaration('let', [
t.variableDeclarator(
t.identifier(opts.identifier),
t.objectExpression(properties)
)
])
opts.declarations.unshift(declaration)
for (let key of Object.keys(value)) {
let property = properties.find(v => {
return v.value.name === key
})
if (property) {
let identifier = property.value.name
toJavascriptAux(value[key], { ...opts, identifier })
}
}
}
} else if (typeof value === 'string') {
let declaration = t.variableDeclaration('let', [
t.variableDeclarator(
t.identifier(opts.identifier),
t.stringLiteral(value)
)
])
opts.declarations.unshift(declaration)
}
}
export const createObjectProperties = (value, opts) => {
let properties = []
let dependancies = opts.dependancies[opts.identifier]
if (!dependancies) dependancies = opts.dependancies[opts.identifier] = []
for (let 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
}
let keyIncrement = opts.keys[key]
if (keyIncrement == 1) {
opts.mappings.push(key)
} else {
opts.mappings.push(key + keyIncrement)
}
opts.keys[key]++
}
let 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 = {}) => {
let schema = {
stringifier: stringifier,
replace (key, value) {
if (opts.firstRun) {
opts.firstRun = !opts.firstRun
return value
}
var 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
}
var 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) => {
var 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')
) {
let 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') {
let 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) {
let 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 = {}) => {
let 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]
let isObject = typeof opts.value === 'object' && opts.value
var 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
let uuid = jsUUID()
var fn
var scopedEval
if (val.$scopedEval && typeof val.$scopedEval == 'function') {
scopedEval = val.$scopedEval
} else {
var fns = createScopedEval(uuid)
try {
fn = eval(`(${fns})`)
var 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) => {
var value = output[key]
// if the value hasn't been revived yet
if (value instanceof String) {
var 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 => {
let 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 => {
let 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 => {
let 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
})
let 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
let property3 = node[0].declarations[0].init.properties[3]
property3.value.scoperWrapped = true
property3.value.body.scopeInitialized = true
let property3ScopesValue =
property3.value.body.body[0].expression.arguments[2].properties[0].value
property3ScopesValue.callee.scoperWrapped = true
property3ScopesValue.callee.body.scopeInitialized = true
let 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
let 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
let property5 = node[0].declarations[0].init.properties[5]
property5.value.callee.scoperWrapped = true
property5.value.callee.body.scopeInitialized = true
let 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
let property6 = node[0].declarations[0].init.properties[6]
property6.value.callee.scoperWrapped = true
property6.value.callee.body.scopeInitialized = true
let 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) {
let 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 => {
let wrapperString = /*javascript*/ `
for(let ${opts.uuid} = function(){
// node goes here
return ${opts.uuid}
}() ; a<1;a++){}
`
let inlineContextNode = opts.aster(wrapperString).init.declarations[0]
let contextBody = createContext({ ...opts, wrapBody: false })
inlineContextNode.init.callee.body.body.splice(0, 0, ...contextBody)
inlineContextNode.contextDeclaration = true
return inlineContextNode
}
export const addBindingsToContext = opts => {
for (let key in opts.path.scope.bindings) {
let binding = opts.path.scope.bindings[key]
if (binding.kind == 'var') {
let newNode = scopeVar({
...opts,
key,
type: binding.kind
})
opts.node.splice(opts.node.length - 1, 0, newNode)
}
}
}
export const scopeVarCode = opts => {
let 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 => {
let 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]
}
let getter = thirdArg.properties[0]
let 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) => {
let 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
let uuid = getPathUUID({ path })
let 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
let metaVisitor = {
Program (path) {
initBlock(path, aster)
},
BlockStatement (path) {
initBlock(path, aster)
},
ForInStatement () {
// nothing
},
// ForInStatement (path) {
// path = path
// },
ObjectMethod (path) {
let 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
let uuid = getPathUUID({ path })
let 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) {
let uuid = getPathUUID({ path })
let 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
let 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'
)
) {
let uuid = getPathUUID({ path })
if (uuid) {
let indexInParent = parentPath.node.declarations.indexOf(path.node)
let 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')
) {
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.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
let uuid = gosmart.bind(this)(path, 'scope.uuid', jsUUID())
if (!parentPath.node.declarations[0].contextDeclaration) {
let inlineContextDeclaration = createInlineContext({
path,
uuid,
aster
})
parentPath.node.declarations.splice(0, 0, inlineContextDeclaration)
}
if (uuid) {
let indexInParent = parentPath.node.declarations.indexOf(path.node)
let 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'
) {
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)
}
} 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)
// }
}
}
}
}
let 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) => {
let 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)
}
let props = Object.keys(value2)
props.forEach(prop => {
let propertyValue1 = value1[prop]
if (prop in value1 && basic(propertyValue1) && !opts.overwrite) {
return
}
let 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 => {
let valueType = typeof value
let 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
let 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) => {
let 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 (var i = 0; i < targets.length; i++) {
let 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 (let 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 (var i = 0; i < list.length; i++) {
if (!(keys && typeof keys.length == 'number')) return
for (var 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 (var i = 0; i < list.length; i++) {
if (!(keys && typeof keys.length == 'number')) return
for (var 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 (let 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 (var 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 (let 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 (var 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 (let 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 (var 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 (let 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 (var 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 (var 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) {
let 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 (let 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 (let 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 (let 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 (let 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 (let 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 (let 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<obj.length; i++){
// // find(obj[i], )
// // }
// // }
// // },
// }
export const getsmart = (
obj,
property,
defaultValue?: any,
context?: any,
schema?: any
) => {
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
}
}
let 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
var nextObj = obj[ee(propsArray[0])]
var remainingProps = propsArray.slice(1)
return deepGetByArray(nextObj, remainingProps, defaultValue)
}
}
export const escapePropertyPath = (path = '') => {
let 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
let char = path[i]
if (i > 0 && i < path.length - 1) {
let prevChar = path[i - 1]
let nextChar = path[i + 1]
let openingArrayPath = char === '"' && prevChar === '['
// && (nextChar !== "\\" || i === path.length-1)
let 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 = '') => {
let array = []
let readingArrayBasedPath = false
let i = 0
let push = false
let pushed = false
while (i < path.length) {
let arrayPathStart = path[i] == '[' && path[i + 1] == '"'
let escapedStart = !(path[i + 1] !== '\\' || i === 0)
if (readingArrayBasedPath) {
// we found the end of an array delimited path
let arrayPathEnd = path[i] == '"' && path[i + 1] == ']'
let 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 {
let 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 = {}
let 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
var 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)
}
let parentPathArray = property.slice(0, property.length - 1)
let path = property[property.length - 1]
let 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
var 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: () => {
var 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
let 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 (var 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]
}
let level = this.pathAsArray.length - 1 - levels
return this.pathAsArray[level]
}
export const getThing = (props = {}) => {
const { list = getsmart.bind(this)(objList), defaultValue = undefined } =
props
var 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
}
Reference in New Issue View Git Blame Copy Permalink