@e280/quay 0.0.0-2 → 0.0.0-20

package/s/logic/aspects/codex/example.ts

@@ -1,7 +1,4 @@
 
-import "@benev/slate/x/node.js"
-import {repeat_string} from "@benev/turtle"
-
 import {Codex} from "./codex.js"
 import {AsSchema, Taxon} from "./parts/types.js"
 
@@ -48,7 +45,7 @@ src
 	//                   we can crawl any folder!
 	//                                    👇
 for (const [item, ancestors] of folder.crawl()) {
-	const indent = repeat_string(ancestors.length, "  ")
+	const indent = "  ".repeat(ancestors.length)
 	const specimen = item.specimen
 	const label = item.kind === "folder"
 		? specimen.label + "/"

package/s/logic/aspects/codex/parts/codex-item.ts

@@ -1,5 +1,5 @@
 
-import {signal} from "@benev/slate"
+import {signal} from "@e280/strata"
 import {Codex} from "../codex.js"
 import {Id, Kind, Schema} from "./types.js"
 
@@ -52,14 +52,14 @@ export class CodexItem<Sc extends Schema = any, K extends Kind<Sc> = Kind<Sc>> {
 	/** add items as children */
 	attach(...items: CodexItem<Sc>[]) {
 		this.codex.hierarchy.attach(this.id, ...items.map(i => i.id))
-		this.signal.publish()
+		this.signal(this)
 		return this
 	}
 
 	/** detach this item from the hierarchy completely */
 	detach() {
 		this.codex.hierarchy.detach(this.id)
-		this.signal.publish()
+		this.signal(this)
 	}
 
 	/** create a new item that will be a child */
@@ -72,7 +72,7 @@ export class CodexItem<Sc extends Schema = any, K extends Kind<Sc> = Kind<Sc>> {
 	/** create a new item that will be a child */
 	destroy() {
 		this.codex.hierarchy.destroy(this.id)
-		this.signal.publish()
+		this.signal(this)
 	}
 
 	/** iterate over this item and all its descendants */

package/s/logic/aspects/codex/parts/hierarchy.ts

@@ -55,6 +55,7 @@ export class Hierarchy {
 
 	/** destroy all relations associated with this id, and all its descendants */
 	destroy(id: Id) {
+		this.detach(id)
 		const tree = [...this.crawl(id)]
 		for (const [id] of tree) {
 			this.#children.delete(id)

package/s/logic/aspects/codex/parts/types.ts

@@ -1,5 +1,5 @@
 
-import {Content} from "@benev/slate"
+import {Content} from "@e280/sly"
 
 export type Id = string
 

package/s/logic/aspects/dropzone.ts

@@ -1,11 +1,12 @@
-import {ShockDragDrop, signal} from "@benev/slate"
+import {loot} from "@e280/sly/loot"
+import {signal} from "@e280/strata"
 
 import {Group} from "../group.js"
 import {CodexItem} from "./codex/parts/codex-item.js"
 
 export class Dropzone {
-	#drag_drop = new ShockDragDrop<CodexItem, CodexItem>({
-		handle_drop: (_e, grabbed, hovering) => this.group.move(grabbed, hovering)
+	#drag_drop = new loot.DragAndDrops<CodexItem, CodexItem>({
+		acceptDrop: (_e, grabbed, hovering) => this.group.move(grabbed, hovering)
 	})
 
 	constructor(private group: Group) {}
@@ -14,37 +15,40 @@ export class Dropzone {
 	#hovering = signal<CodexItem | undefined>(undefined)
 
 	get grabbed() {
-		return this.#drag_drop.grabbed
+		return this.#drag_drop.dragging
 	}
 
 	get hovering() {
-		return this.#drag_drop.hovering ?? this.#hovering.value
+		return this.#drag_drop.hovering ?? this.#hovering()
 	}
 
-	dragenter = (e: DragEvent, target?: CodexItem) => {
+	dragenter = (e: DragEvent, target: CodexItem) => {
 		e.preventDefault()
-		this.#drag_drop.dropzone.dragenter()(e)
-		this.#hovering.value = target
+		this.#drag_drop.dropzone(() => target).dragenter(e)
+		this.#hovering(target)
 	}
 
 	dragleave = (e: DragEvent) => {
-		this.#drag_drop.dropzone.dragleave()(e)
-		this.#hovering.value = undefined
+		const hovering = this.hovering
+		if (hovering)
+			this.#drag_drop.dropzone(() => hovering).dragleave(e)
+		this.#hovering(undefined)
 	}
 
 	dragstart = (e: DragEvent, n: CodexItem) => {
 		e.stopPropagation()
-		this.#drag_drop.dragzone.dragstart(n)(e)
+		this.#drag_drop.dragzone(() => n).dragstart(e)
 	}
 
 	dragover = (e: DragEvent, n: CodexItem) => {
 		e.preventDefault()
-		this.#drag_drop.dropzone.dragover(n)(e)
+		this.#drag_drop.dropzone(() => n).dragover(e)
 	}
 
 	dragend = (e: DragEvent) => {
-		this.#drag_drop.dragzone.dragend()(e)
-		this.#hovering.value = undefined
+		this.#drag_drop.$draggy(undefined)
+		this.#drag_drop.$droppy(undefined)
+		this.#hovering(undefined)
 	}
 
 	drop = (e: DragEvent, target: CodexItem) => {
@@ -60,9 +64,9 @@ export class Dropzone {
 		const parent = this.grabbed?.parent?.id === this.hovering?.id
 
 		if(!same && !child && !parent)
-			this.#drag_drop.dropzone.drop(target)(e)
+			this.#drag_drop.dropzone(() => target).drop(e)
 
-		this.#hovering.value = undefined
+		this.#hovering(undefined)
 	}
 
 	change = (e: DragEvent, targetFolder: CodexItem) => {

package/s/logic/aspects/tree-trail.ts

@@ -1,4 +1,5 @@
-import {signal} from "@benev/slate"
+
+import {signal} from "@e280/strata"
 import {Schema} from "./codex/parts/types.js"
 import {CodexItem} from "./codex/parts/codex-item.js"
 
@@ -6,7 +7,7 @@ export class TreeTrail<Sc extends Schema> {
 	readonly signal = signal<CodexItem<Sc>[]>([])
 
 	constructor(root: CodexItem<Sc>) {
-		this.signal.value = [root]
+		this.signal([root])
 	}
 
 	setTrail(e: Event, item: CodexItem<Sc>) {
@@ -23,11 +24,11 @@ export class TreeTrail<Sc extends Schema> {
 			cur = cur.parent
 		}
 
-		this.signal.value = trail
+		this.signal(trail)
 	}
 
 	get currentFolder() {
-		return this.signal.value.at(-1)?.children ?? []
+		return this.signal().at(-1)?.children ?? []
 	}
 }
 

package/s/logic/brain.ts

@@ -2,6 +2,8 @@
 import {MapG} from "@e280/stz"
 import {Group} from "./group.js"
 
+type RegisteredGroup<G> = G extends Group<infer _Schema> ? G : never
+
 /**
  * Quay's global state
  *  - manages groups
@@ -10,13 +12,13 @@ import {Group} from "./group.js"
 export class Brain {
 	#groups = new MapG<string, Group>()
 
-	setGroup<G extends Group>(name: string, group: G) {
+	setGroup<G>(name: string, group: RegisteredGroup<G>) {
 		this.#groups.set(name, group)
 		return group
 	}
 
-	getGroup<G extends Group>(name: string) {
-		return this.#groups.require(name) as G
+	getGroup<G = Group>(name: string) {
+		return this.#groups.require(name) as RegisteredGroup<G>
 	}
 }
 

package/s/logic/group.ts

@@ -1,5 +1,5 @@
 import {sub} from "@e280/stz"
-import {signal} from "@benev/slate"
+import {signal} from "@e280/strata"
 
 import {Permission} from "./permissions.js"
 import {Dropzone} from "./aspects/dropzone.js"
@@ -18,7 +18,7 @@ export class Group<Sc extends Schema = any> {
 	on = {
 		newFolder: sub<[{parent: CodexItem<Sc>}]>(),
 		move: sub<[{item: CodexItem<Sc>, target: CodexItem<Sc>}]>(),
-		delete: sub<[{item: CodexItem<Sc>}]>(),
+		delete: sub<[{items: CodexItem<Sc>[]}]>(),
 		rename: sub<[{item: CodexItem<Sc>, newName: string}]>(),
 		upload: sub<[{files: File[], target: CodexItem<Sc>}]>(),
 		search: sub<[{terms: string[]}]>(),
@@ -26,13 +26,13 @@ export class Group<Sc extends Schema = any> {
 	}
 
 	constructor(public config: GroupConfig<Sc>) {
-		this.selectedFilter.value = config.defaultFilter
-		this.selectedSort.value = config.defaultSort
+		this.selectedFilter(config.defaultFilter)
+		this.selectedSort(config.defaultSort)
 		this.trail = new TreeTrail(config.root)
 	}
 
 	get permissions() {
-		return this.config.permissions as (item: CodexItem) => Permission
+		return this.config.permissions as (item: CodexItem<Sc>) => Permission
 	}
 
 	getFilterFn(filterKey: string): SearchFn<Sc> {
@@ -49,13 +49,13 @@ export class Group<Sc extends Schema = any> {
 	}
 
 	sort(items: CodexItem<Sc>[]): CodexItem<Sc>[] {
-		const sortFn = this.getSortFn(this.selectedSort.value)
+		const sortFn = this.getSortFn(this.selectedSort())
 		return [...items].sort(sortFn)
 	}
 
 	matches(item: CodexItem<Sc>) {
-		const filterFn = this.getFilterFn(this.selectedFilter.value)
-		const searchFn = this.getSearchFn(this.searchText.value)
+		const filterFn = this.getFilterFn(this.selectedFilter())
+		const searchFn = this.getSearchFn(this.searchText())
 		return filterFn(item) && searchFn(item)
 	}
 
@@ -73,9 +73,11 @@ export class Group<Sc extends Schema = any> {
 		if(!this.permissions(item).delete)
 			throw new Error("delete permission not granted")
 
+		const items = [...item.crawl()].map(([item]) => item)
+
 		item.destroy()
 
-		this.on.delete.pub({item})
+		return this.on.delete.pub({items})
 	}
 
 	rename(item: CodexItem<Sc>, newName: string) {
@@ -89,7 +91,8 @@ export class Group<Sc extends Schema = any> {
 		if(!this.permissions(folder).upload)
 			throw new Error("upload permission not granted")
 
-		this.on.upload.pub({files, target: folder})
+		return this.on.upload.pub({files, target: folder})
+			.then(() => this.on.refresh.pub({}))
 	}
 
 	addFolder(parent: CodexItem<Sc>) {

package/s/logic/presets/media/group.ts

@@ -1,15 +1,16 @@
 
+import {html} from "lit"
 import {MapG} from "@e280/stz"
-import {Content, html} from "@benev/slate"
+import {Content} from "@e280/sly"
 
-import Quay from "../../../index.js"
 import {Group} from "../../group.js"
+import {Permissions} from "../../permissions.js"
 import {Codex} from "../../aspects/codex/codex.js"
 import {MediaFormat, MediaSchema} from "./schema.js"
 import {GroupConfig, SearchFn, SortFn} from "../../types.js"
 import {CodexItem} from "../../aspects/codex/parts/codex-item.js"
 
-export class MediaGroup extends Group<MediaSchema> implements Group {
+export class MediaGroup extends Group<MediaSchema> {
 	static config = (): GroupConfig<MediaSchema> => {
 		const formatIcons = new MapG<MediaFormat, Content>()
 			.set("audio", html`<sl-icon name=music-note-beamed></sl-icon>`)
@@ -83,7 +84,7 @@ export class MediaGroup extends Group<MediaSchema> implements Group {
 					// // TODO icons
 					// : html`<sl-icon name=${item.taxon.icon}></sl-icon>`
 			},
-			permissions: item => Quay.permissions.all,
+			permissions: item => Permissions.all,
 		}
 	}
 

package/s/logic/presets/media/library.test.ts

@@ -0,0 +1,82 @@
+
+import {Txt} from "@e280/stz"
+import {expect, Science, test} from "@e280/science"
+
+import {MediaLibrary} from "./library.js"
+import {Permissions} from "../../permissions.js"
+
+delete (globalThis as any).localStorage
+
+export default Science.suite({
+	"uploads files into cellar and index": test(async() => {
+		const group = new MediaLibrary()
+		await group.upload([file("hello.txt", "hello")], group.config.root)
+
+		const record = await recordByLabel(group, "hello.txt")
+		const item = group.findByHash(record.hash)!
+
+		expect(item.specimen.label).is("hello.txt")
+		expect(await group.cellar.has(record.hash)).is(true)
+	}),
+
+	"upload respects upload permission": test(async() => {
+		const group = new MediaLibrary()
+		const file = new File([Txt.toBytes("hello")], "hello.txt", {type: "text/plain"})
+		group.config.permissions = () => Permissions.readOnly
+
+		expect(() => group.upload([file], group.config.root)).throws()
+	}),
+
+	"lists media records": test(async() => {
+		const store = new MediaLibrary()
+		await store.upload([file("image.png", "image", "image/png")], store.config.root)
+
+		expect(await recordByLabel(store, "image.png")).ok()
+	}),
+
+	"includes existing media in a scope": test(async() => {
+		const library = new MediaLibrary()
+		await library.upload([file("include.txt", "include")], library.config.root)
+		const record = await recordByLabel(library, "include.txt")
+		const project = await library.scope("include-project")
+
+		await project.include(record.hash)
+
+		expect(project.findByHash(record.hash)).ok()
+		expect(await recordByLabel(project, "include.txt")).ok()
+		expect(await project.cellar.has(record.hash)).is(true)
+		await expect(() => project.include("missing")).throwsAsync()
+	}),
+
+	"root deletion removes media records and resources": test(async() => {
+		const store = new MediaLibrary()
+		await store.upload([file("delete.png", "delete-image", "image/png")], store.config.root)
+
+		const record = await recordByLabel(store, "delete.png")
+		const item = store.findByHash(record.hash)!
+
+		await store.delete(item)
+
+		expect(store.findByHash(record.hash)).is(undefined)
+		expect(await store.cellar.has(record.hash)).is(false)
+	}),
+
+})
+
+function file(name: string, text: string, type = "text/plain") {
+	return new File([Txt.toBytes(text)], name, {type})
+}
+
+async function records(store: MediaLibrary) {
+	const records = []
+	for await (const record of store.records())
+		records.push(record)
+	return records
+}
+
+async function recordByLabel(store: MediaLibrary, label: string) {
+	const record = (await records(store)).find(r => r.label === label)
+	if (!record)
+		throw new Error(`expected record "${label}"`)
+	return record
+}

package/s/logic/presets/media/library.ts

@@ -0,0 +1,249 @@
+
+import {collect, sub} from "@e280/stz"
+import {Kv, StorageMagazine} from "@e280/kv"
+
+import {MediaGroup} from "./group.js"
+import {Cellar} from "../../../cellar/cellar.js"
+import {MediaFormat, MediaProgress, MediaSchema} from "./schema.js"
+import {CodexItem} from "../../aspects/codex/parts/codex-item.js"
+
+export type MediaRecord = {
+	hash: string
+	label: string
+	format: MediaFormat
+	mime: string
+	size: number
+	createdAt: number
+	updatedAt: number
+}
+
+export class MediaLibrary extends MediaGroup {
+	static async open(scope = "default") {
+		const group = new this()
+		group.cellar = await Cellar.opfs("media")
+		group.#index = mediaIndex(scope)
+		group.#lineage = [group.#index]
+		await group.#load()
+		return group
+	}
+
+	#index
+	#lineage
+	#root = this
+	#objectUrls = new Map<string, string>()
+
+	progress = sub<[MediaProgress]>()
+	cellar = new Cellar()
+
+	constructor() {
+		super()
+		this.#index = mediaIndex("default")
+		this.#lineage = [this.#index]
+		this.on.upload.sub(({files, target}) => {
+			return this.#upload(files, target)
+		})
+		this.on.delete.sub(({items}) => {
+			const hashes = this.#hashes(items)
+			return this.#delete(hashes)
+		})
+	}
+
+	get #isRoot() {
+		return this === this.#root
+	}
+
+	async scope(name: string) {
+		const child = new MediaLibrary()
+		child.cellar = this.cellar
+		child.#index = this.#index.scope<MediaRecord>(name)
+		child.#lineage = [...this.#lineage, child.#index]
+		child.#root = this.#root
+		await child.#load()
+		return child
+	}
+
+	async *records() {
+		for await (const [, record] of this.#index.entries())
+			yield record
+	}
+
+	async include(hash: string) {
+		const record = await this.#root.#index.need(hash)
+		await this.#index.commit(this.#lineage.map(index => index.op.set(hash, record)))
+		if (record.format === "image" && !this.#objectUrls.has(hash))
+			await this.#loadPreview(record)
+		this.#attachRecord(record)
+		this.on.refresh.pub({})
+	}
+
+	async #load() {
+		for await (const record of this.records()) {
+			if (record.format === "image" && !this.#objectUrls.has(record.hash))
+				await this.#loadPreview(record)
+			this.#attachRecord(record, this.config.root)
+		}
+	}
+
+	async #upload(files: File[], parent: CodexItem<MediaSchema>) {
+		await Promise.all(files.map(file => this.#storeFile(file, parent)))
+	}
+
+	async #storeFile(file: File, parent: CodexItem<MediaSchema>) {
+		const item = this.#attachPending(file, parent)
+
+		try {
+			const hash = await this.cellar.write(trackProgress(file.stream(), loaded =>
+				this.progress.pub({item, loaded, total: file.size})
+			))
+			const record = await this.#saveRecord(file, hash)
+			item.destroy()
+			this.#attachRecord(record, parent)
+			return record
+		}
+		catch (error) {
+			item.destroy()
+			this.on.refresh.pub({})
+			throw error
+		}
+	}
+
+	#attachPending(file: File, parent: CodexItem<MediaSchema>) {
+		const item = this.config.codex.create("file", {
+			label: file.name,
+			format: mediaFormat(file.type),
+			mime: file.type,
+			size: file.size,
+			previewUrl: null,
+		})
+		parent.attach(item)
+		this.on.refresh.pub({})
+		return item
+	}
+
+	async #saveRecord(file: File, hash: string) {
+		const existing = await this.#index.get(hash) ?? await this.#root.#index.get(hash)
+		const now = Date.now()
+		const record: MediaRecord = {
+			hash,
+			label: existing?.label ?? file.name,
+			format: mediaFormat(file.type),
+			mime: file.type,
+			size: file.size,
+			createdAt: existing?.createdAt ?? now,
+			updatedAt: now,
+		}
+		await this.#index.commit(this.#lineage.map(index => index.op.set(hash, record)))
+		if (record.format === "image")
+			this.#setPreview(hash, URL.createObjectURL(file))
+		return record
+	}
+
+	#hashes(items: CodexItem<MediaSchema>[]) {
+		return items
+			.map(item => item.isKind("file") ? item.specimen.hash : undefined)
+			.filter((hash): hash is string => !!hash)
+	}
+
+	async #delete(hashes: string[]) {
+		const index = this.#index.crush()
+		const keys = (await collect(index.entries()))
+			.filter(([, record]) => hashes.includes(record.hash))
+			.map(([key]) => key)
+		await index.commit(keys.map(key => index.op.delete(key)))
+
+		for (const hash of hashes) {
+			this.#revokePreview(hash)
+			if (this.#isRoot)
+				await this.cellar.delete(hash)
+		}
+	}
+
+	findByHash(hash: string) {
+		for (const [item] of this.config.root.crawl()) {
+			if (item.isKind("file") && item.specimen.hash === hash)
+				return item
+		}
+	}
+
+	dispose() {
+		for (const url of this.#objectUrls.values())
+			URL.revokeObjectURL(url)
+		this.#objectUrls.clear()
+	}
+
+	#attachRecord(record: MediaRecord, parent = this.config.root) {
+		const existing = this.findByHash(record.hash)
+		if (existing)
+			return existing
+
+		const item = this.config.codex.create("file", {
+			hash: record.hash,
+			label: record.label,
+			format: record.format,
+			mime: record.mime,
+			size: record.size,
+			previewUrl: this.#objectUrls.get(record.hash) ?? null,
+		})
+		parent.attach(item)
+		return item
+	}
+
+	async #loadPreview(record: MediaRecord) {
+		const cask = await this.cellar.load(record.hash)
+		const blob = new Blob([cask.file], {type: record.mime || "image/*"})
+		return this.#setPreview(record.hash, URL.createObjectURL(blob))
+	}
+
+	#setPreview(hash: string, url: string) {
+		this.#revokePreview(hash)
+		this.#objectUrls.set(hash, url)
+		return url
+	}
+
+	#revokePreview(hash: string) {
+		const url = this.#objectUrls.get(hash)
+		if (url) {
+			URL.revokeObjectURL(url)
+			this.#objectUrls.delete(hash)
+		}
+	}
+}
+
+const mediaFormats = new Set(["video", "image", "audio"])
+const memoryIndexes = new Map<string, Kv<MediaRecord>>()
+
+function mediaFormat(mime: string): MediaFormat {
+	const [type] = mime.split("/")
+	return mediaFormats.has(type) ? type as MediaFormat : "other"
+}
+
+function mediaIndex(scope: string) {
+	const storage = globalThis.localStorage
+	if (storage)
+		return new Kv<MediaRecord>(new StorageMagazine(storage))
+			.scope("quay")
+			.scope("media")
+			.scope<MediaRecord>(scope)
+
+	const existing = memoryIndexes.get(scope)
+	if (existing)
+		return existing
+
+	const index = new Kv<MediaRecord>()
+	memoryIndexes.set(scope, index)
+	return index
+}
+
+function trackProgress(
+		readable: ReadableStream<Uint8Array>,
+		onProgress: (loaded: number) => void,
+	) {
+	let loaded = 0
+	return readable.pipeThrough(new TransformStream({
+		transform(chunk, controller) {
+			loaded += chunk.byteLength
+			onProgress(loaded)
+			controller.enqueue(chunk)
+		},
+	}))
+}

package/s/logic/presets/media/schema.ts

@@ -1,6 +1,7 @@
 
-import {Content} from "@benev/slate"
+import {Content} from "@e280/sly"
 import {AsSchema} from "../../aspects/codex/parts/types.js"
+import {CodexItem} from "../../aspects/codex/parts/codex-item.js"
 
 export type MediaFormat = "video" | "image" | "audio" | "other"
 
@@ -16,7 +17,15 @@ export type MediaSchema = AsSchema<{
 			label: string
 			format: MediaFormat
 			previewUrl: string | null
+			hash?: string
+			mime?: string
+			size?: number
 		}
 	}
 }>
 
+export type MediaProgress = {
+	item: CodexItem<MediaSchema>
+	loaded: number
+	total: number
+}

package/s/logic/presets/opfs/schema.ts

@@ -1,5 +1,5 @@
 
-import {Content} from "@benev/slate"
+import {Content} from "@e280/sly"
 import {AsSchema} from "../../aspects/codex/parts/types.js"
 
 export type OpfsSchema = AsSchema<{

package/s/logic/presets/plain/group.ts

@@ -1,7 +1,7 @@
 
-import Quay from "../../../index.js"
 import {Group} from "../../group.js"
 import {PlainSchema} from "./schema.js"
+import {Permissions} from "../../permissions.js"
 import {GroupConfig, SortFn} from "../../types.js"
 import {Codex} from "../../aspects/codex/codex.js"
 
@@ -33,7 +33,7 @@ export class PlainGroup extends Group<PlainSchema> {
 			renderLabel: item => item.id,
 			renderIcon: item => item.taxon.icon,
 			renderPreview: () => null,
-			permissions: item => Quay.permissions.all,
+			permissions: item => Permissions.all,
 		}
 	}