Upgraded dependencies to "latest"

Author: Zaydek Michels-Gualtieri

notes/notes-2.js

@@ -2,12 +2,12 @@
 	"name": "codex-wysiwyg",
 	"dependencies": {
 		"emoji-trie": "https://github.com/codex-src/emoji-trie.js",
-		"lodash": "^4.17.19",
-		"react": "next",
-		"react-dom": "next",
-		"react-scripts": "next",
-		"use-immer": "^0.4.1",
-		"uuidv4": "^6.1.0"
+		"lodash": "latest",
+		"react": "latest",
+		"react-dom": "latest",
+		"react-scripts": "latest",
+		"use-immer": "latest",
+		"uuidv4": "latest"
 	},
 	"scripts": {
 		"tailwind-start": "tailwind build -c src/tailwind-css/js/tailwind.config.js -o src/tailwind-css/css/tailwind.generated.css",
@@ -33,9 +33,9 @@
 		]
 	},
 	"devDependencies": {
-		"@tailwindcss/ui": "^0.4.0",
+		"@tailwindcss/ui": "latest",
 		"debug.css": "https://github.com/codex-src/debug.css",
-		"serve": "^11.3.2",
-		"tailwindcss": "^1.6.2"
+		"serve": "latest",
+		"tailwindcss": "latest"
 	}
 }

notes/notes.js

@@ -102,6 +102,199 @@ function fn(children) {
 	// ...
 }
 
+// function doSomething(children) {
+// 	const cloned = JSONClone(children)
+// 	for (let x1 = 0; x1 < children.length; x1++) {
+// 		for (let x2 = x1; x2 < children.length; x2++) {
+// 			// ...
+// 		}
+// 		// recurse?
+// 	}
+// 	// iterate?
+// }
+
+const children = [
+	{
+		types: {
+			code: {},
+		},
+		props: {
+			children: "aaa"
+		},
+	},
+	{
+		types: {
+			code: {},
+			strong: {},
+		},
+		props: {
+			children: "bbb",
+		},
+	},
+	{
+		types: {
+			code: {},
+			strong: {},
+			strong: {},
+		},
+		props: {
+			children: "ccc",
+		},
+	},
+	{
+		types: {
+			code: {},
+			strong: {},
+		},
+		props: {
+			children: "ddd",
+		},
+	},
+	{
+		types: {
+			code: {},
+		},
+		props: {
+			children: "eee"
+		},
+	},
+]
+
+function JSONEqual(v1 , v2) {
+	const ok = (
+		JSON.stringify(v1) === JSON.stringify(v2)
+	)
+	return ok
+}
+
+// Returns whether types have one or more types in common.
+function hasOneOrMoreTypesInCommon(types1, types2) {
+	return Object.keys(types1).some(each => JSONEqual(types1[each], types2[each]))
+
+	// for (const each of Object.keys(types1)) {
+	// 	if (types2[each] && JSONEqual(types1[each], types2[each])) {
+	// 		return true
+	// 	}
+	// }
+	// return false
+}
+
+// aaa
+// -> bbb
+// -> -> ccc
+// -> ddd
+// eee
+
+// // Emits an <AnyList> element.
+// function emitAnyList(range) {
+// 	const { parent } = parseMetadata(range[0])
+// 	const element = {
+// 		...parent,
+// 		children: [],
+// 	}
+// 	for (const each of range) {
+// 		const { matches, parent, ...etc } = parseMetadata(each)
+// 		const [, tabs, syntax] = matches
+// 		let ref = element.children
+// 		for (let x = 0; x < tabs.length; x++) {
+// 			if (!ref.length || ref[ref.length - 1].type !== typeEnum.AnyList) {
+// 				ref.push({
+// 					...parent,
+// 					children: [],
+// 				})
+// 			}
+// 			ref = ref[ref.length - 1].children
+// 		}
+// 		ref.push({
+// 			...etc,
+// 			syntax: [tabs + syntax],
+// 			children: parseInlineElements(each.data.slice((tabs + syntax).length)),
+// 		})
+// 	}
+// 	return element
+// }
+
+// find the longest chain
+// recurse on the contents of the chain, **excluding the
+// types the longest has in common**?
+
+function render(children, types) {
+	const tree = {}
+	for (const each of types) {
+		Object.assign(tree, {
+			...children, // ??
+			type: each,
+			props: {
+				....children.props,
+			},
+		})
+	}
+	return tree
+}
+
+function (children, ctx) {
+	let tree = []
+	for () {
+		for () {
+			const common = getCommonTypes(children, ctx)
+			if (!common) {
+				tree.push(render())
+			} else {
+				tree.push(recurse(common))
+			}
+		}
+	}
+	return tree
+}
+
+function fn(children) {
+	let x1 = 0
+	for (; x1 < children.length; x1++) {
+		let x2 = x1 + 1
+		for (; x2 < children.length; x2++) {
+			if (!hasOneOrMoreTypesInCommon(children[x1].types, children[x2].types)) {
+				// No-op
+				break
+			}
+		}
+		x1 = x2
+		console.log({ x1 })
+	}
+}
+
+fn(children)
+
+	// let x = 1
+	// for (; x < children.length; x++) {
+	// 	if (!hasOneOrMoreTypesInCommon(children[0].types, children[x].types)) {
+	// 		// No-op
+	// 		break
+	// 	}
+	// }
+	// if (children.slice(1, x).length) {
+	// 	fn(children.slice(1, x))
+	// }
+	// console.log(children.slice(0, x))
+}
+
+fn(children)
+
+// function doSomething(children, typesCtx = {}) {
+// 	for (let x = 0; x < children.length - 1; x++) {
+// 		if (x + 1 < children.length - 1) {
+// 			if (!JSONEqual(children[x], children[x + 1])) {
+// 				render(children[x])
+// 				// recurse(children.slice(x + 1))
+// 			}
+// 		}
+// 	}
+// }
+
+// function typesAreStrictlyCommon(types1, types2) {
+// 	return JSONEqual(types1, types2)
+// }
+
+
 // Stress test
 
 //   -   code