@pathmx/core 0.5.0

package/plugins/input/index.ts

@@ -0,0 +1,359 @@
+import { defineAction } from "../../actions/actions.ts"
+import { html, type Html } from "../../html.ts"
+import { publicPath } from "../../server/router.ts"
+import { SourceDiagnosticError } from "../../source-diagnostic.ts"
+import {
+  defineViewComponent,
+  defineViewVariable,
+  type AppContext,
+  type Plugin,
+  type PluginInvalidationTarget,
+  type Source,
+  type ViewContext,
+} from "../types.ts"
+import {
+  inspectInputSource,
+  type InputAuthoring,
+  optionFrom,
+  optionProps,
+  submitProps,
+  textFrom,
+  textProps,
+} from "./authoring.ts"
+import { InputModelIndex, type InputChoice, type InputText } from "./model.ts"
+import { InputStateIndex, type InputValue, type InputValues } from "./state.ts"
+import { InputResponsePropSchema, inputResponseConfig } from "./config.ts"
+
+type InputProjection = Readonly<{
+  values?: InputValues
+  editable: boolean
+}>
+
+const PENDING_EVIDENCE = Object.freeze({})
+
+function selected(value: InputValue | undefined, option: string) {
+  return Array.isArray(value) ? value.includes(option) : value === option
+}
+
+function presence(name: string, enabled: boolean): Html {
+  return enabled ? html` ${name}` : ""
+}
+
+function renderOption(
+  option: InputChoice,
+  inputValue: InputValue | undefined,
+  editable: boolean,
+) {
+  const checked = presence("checked", selected(inputValue, option.value))
+  const required = presence("required", option.required)
+  const disabled = presence("disabled", !editable)
+  return html`<label class="input-option"
+    ><input
+      type="${option.type}"
+      name="${option.name}"
+      value="${option.value}"
+      ${checked}${required}${disabled}
+    /><span>${option.label}</span></label
+  >`
+}
+
+function renderText(
+  control: InputText,
+  inputValue: InputValue | undefined,
+  editable: boolean,
+) {
+  const value = typeof inputValue === "string" ? inputValue : ""
+  const required = presence("required", control.required)
+  const disabled = presence("disabled", !editable)
+  const placeholder = control.placeholder
+    ? html` placeholder="${control.placeholder}"`
+    : ""
+  return control.type === "textarea"
+    ? html`<label class="input-field input-textarea"
+        ><span>${control.label}</span
+        ><textarea name="${control.name}" ${placeholder}${required}${disabled}>
+${value}</textarea>
+      </label>`
+    : html`<label class="input-field input-text"
+        ><span>${control.label}</span
+        ><input
+          type="text"
+          name="${control.name}"
+          value="${value}"
+          ${placeholder}${required}${disabled}
+      /></label>`
+}
+
+function inputDiagnostic(source: Source, message: string) {
+  return new SourceDiagnosticError({
+    source: source.path,
+    plugin: "input",
+    message,
+  })
+}
+
+function inputPlugin(
+  models: InputModelIndex,
+  states: InputStateIndex,
+  authoring: readonly InputAuthoring[],
+): Plugin {
+  const projected = new WeakMap<ViewContext, Map<string, InputProjection>>()
+  const resolveState = (origin: Source, actorId?: string) => {
+    try {
+      return states.resolve(origin, actorId)
+    } catch (error) {
+      throw inputDiagnostic(
+        origin,
+        error instanceof Error ? error.message : String(error),
+      )
+    }
+  }
+
+  const projectionFor = (
+    origin: Source,
+    view: ViewContext,
+    app: AppContext,
+  ) => {
+    let byOrigin = projected.get(view)
+    if (!byOrigin) {
+      byOrigin = new Map()
+      projected.set(view, byOrigin)
+    }
+    const cached = byOrigin.get(origin.id)
+    if (cached) return cached
+
+    const actorId =
+      view.session.type === "authenticated" ? view.session.actor.id : undefined
+    const principal = view.view.principal
+    const binding = resolveState(origin, actorId)
+    const stored = binding.state
+    const readable = stored
+      ? app.access.can(principal, stored.source, "read")
+      : false
+    const writable = stored
+      ? app.access.can(principal, stored.source, "write")
+      : binding.type === "actor-relative" && actorId != null
+    const projection: InputProjection = {
+      values:
+        stored && readable
+          ? models.validate(origin.path, stored.values)
+          : undefined,
+      editable: writable && app.access.can(principal, origin, "execute"),
+    }
+    byOrigin.set(origin.id, projection)
+    return projection
+  }
+
+  const option = (type: InputChoice["type"]) =>
+    defineViewComponent({
+      tag: `input:${type}`,
+      props: optionProps,
+      compile(use) {
+        // View compilation runs after indexing, so this validates any bound State.
+        resolveState(use.origin)
+        return optionFrom(use, type)
+      },
+      render(use, compiled, view, app) {
+        const projection = projectionFor(use.origin, view, app)
+        return renderOption(
+          compiled,
+          projection.values?.[use.props.name!],
+          projection.editable,
+        )
+      },
+    })
+
+  const text = (type: InputText["type"]) =>
+    defineViewComponent({
+      tag: `input:${type}`,
+      props: textProps,
+      compile(use) {
+        resolveState(use.origin)
+        return textFrom(use, type)
+      },
+      render(use, compiled, view, app) {
+        const projection = projectionFor(use.origin, view, app)
+        return renderText(
+          compiled,
+          projection.values?.[use.props.name!],
+          projection.editable,
+        )
+      },
+    })
+
+  const submit = defineViewComponent({
+    tag: "input:submit",
+    props: submitProps,
+    render(use, _compiled, view, app) {
+      const disabled = presence(
+        "disabled",
+        !projectionFor(use.origin, view, app).editable,
+      )
+      return html`<button
+        type="submit"
+        formaction="/actions/input:submit"
+        formmethod="post"
+        ${disabled}
+      >
+        ${use.props.label}
+      </button>`
+    },
+  })
+
+  const submitAction = defineAction({
+    title: "Save response",
+    description: "Save the current actor's response to this Source.",
+    affordance: ({ target, principal, can }) =>
+      models.has(target.path) && principal.type === "actor" && can("execute"),
+    authorize: ({ target }) =>
+      Boolean(target && models.has(target.path)) ||
+      "Input Action requires an originating Source.",
+    async execute(input, { actor, target, tx, yaml }) {
+      if (!target)
+        throw new Error("Input Action requires an originating Source.")
+      const values = models.validate(target.path, input)
+      await states.write(tx, actor, target, values, yaml)
+    },
+  })
+
+  return {
+    id: "input",
+    name: "InputPlugin",
+    schema: {
+      props: { "input-response": InputResponsePropSchema },
+      actions: { submit: submitAction },
+    },
+    components: [
+      text("text"),
+      text("textarea"),
+      option("radio"),
+      option("checkbox"),
+      submit,
+    ],
+    variables: [
+      defineViewVariable({
+        namespace: "input",
+        render(use, view, app) {
+          if (use.path.length !== 1) return
+          const value = projectionFor(use.origin, view, app).values?.[
+            use.path[0]!
+          ]
+          return Array.isArray(value) ? value.join(", ") : value
+        },
+      }),
+    ],
+    index(source, app) {
+      const inspected = inspectInputSource(source, authoring)
+      if (inspected.issues[0]) {
+        throw inputDiagnostic(source, inspected.issues[0])
+      }
+      try {
+        models.replace(source, inspected.controls, inspected.completion)
+      } catch (error) {
+        throw inputDiagnostic(
+          source,
+          error instanceof Error ? error.message : String(error),
+        )
+      }
+      states.index(source, app)
+    },
+    unindex(sourcePath) {
+      states.unindex(sourcePath)
+      models.unindex(sourcePath)
+    },
+    lint(report, app) {
+      for (const source of app.sources.all()) {
+        for (const issue of inspectInputSource(source, authoring).issues) {
+          report(source, issue)
+        }
+        if (!inputResponseConfig(source)?.state) continue
+        try {
+          states.resolve(source)
+        } catch (error) {
+          report(source, error instanceof Error ? error.message : String(error))
+        }
+      }
+      for (const state of states.records()) {
+        if (state.statusIssue) {
+          report(
+            state.source,
+            `Invalid Input state in ${state.source.path}: ${state.statusIssue}`,
+          )
+        }
+        const origin = app.sources.get(state.originId)
+        if (!origin) {
+          report(
+            state.source,
+            `Input State ${state.source.path} targets missing Source ${state.originId}.`,
+          )
+          continue
+        }
+        try {
+          models.validate(origin.path, state.values)
+        } catch (error) {
+          report(
+            state.source,
+            error instanceof Error ? error.message : String(error),
+          )
+        }
+      }
+    },
+    invalidate(transition, app) {
+      const targets: PluginInvalidationTarget[] = []
+      for (const source of [transition.before, transition.after]) {
+        const record = states.transition(source, app)
+        if (!record) continue
+        const origin = app.sources.get(record.originId)
+        if (!origin) continue
+        targets.push(
+          states.isBound(origin, record.source.id)
+            ? { type: "route", route: publicPath(origin) }
+            : {
+                type: "route",
+                route: publicPath(origin),
+                actors: [record.actorId],
+              },
+        )
+      }
+      return targets.length ? { targets } : undefined
+    },
+  }
+}
+
+export function createInputPlugin(
+  options: Readonly<{ authoring?: readonly InputAuthoring[] }> = {},
+) {
+  const models = new InputModelIndex()
+  const states = new InputStateIndex()
+  const authoring = Object.freeze([...(options.authoring ?? [])])
+  return Object.freeze({
+    plugin: () => inputPlugin(models, states, authoring),
+    completion: Object.freeze({
+      declarations(source: Source) {
+        const target = models.completion(source.id)
+        return target ? Object.freeze([Object.freeze({ key: target.key })]) : []
+      },
+      read(actorId: string, ref: Readonly<{ source: string; key: string }>) {
+        const target = models.completion(ref.source)
+        if (!target || target.key !== ref.key) return
+        const state = states.forActor(actorId, ref.source)
+        if (!state?.submittedAt) return PENDING_EVIDENCE
+        try {
+          models.validateSource(ref.source, state.values)
+          return Object.freeze({
+            fact: Object.freeze({
+              outcome: "complete" as const,
+              occurredAt: state.submittedAt,
+            }),
+          })
+        } catch {
+          return PENDING_EVIDENCE
+        }
+      },
+    }),
+  })
+}
+
+export function InputPlugin(): Plugin {
+  return createInputPlugin().plugin()
+}

package/plugins/input/model.ts

@@ -0,0 +1,173 @@
+import type { ActionInput } from "../../actions/actions.ts"
+import type { Source } from "../../source/index.ts"
+import type { InputValues } from "./state.ts"
+
+export type InputChoice = Readonly<{
+  type: "radio" | "checkbox"
+  name: string
+  value: string
+  label: string
+  required: boolean
+  min: number
+}>
+
+export type InputText = Readonly<{
+  type: "text" | "textarea"
+  name: string
+  label: string
+  placeholder?: string
+  required: boolean
+}>
+
+export type InputControl = InputChoice | InputText
+
+type InputChoiceField = {
+  type: InputChoice["type"]
+  options: Set<string>
+  required: boolean
+  min: number
+}
+
+type InputTextField = {
+  type: InputText["type"]
+  required: boolean
+}
+
+type InputField = InputChoiceField | InputTextField
+
+function isChoice(control: InputControl): control is InputChoice {
+  return control.type === "radio" || control.type === "checkbox"
+}
+
+function isChoiceField(field: InputField): field is InputChoiceField {
+  return field.type === "radio" || field.type === "checkbox"
+}
+
+function textValue(name: string, required: boolean, raw: unknown) {
+  if (raw == null || raw === "") {
+    if (required) throw new Error(`Input field ${name} is required.`)
+    return
+  }
+  if (typeof raw !== "string") {
+    throw new Error(`Invalid value for Input field ${name}.`)
+  }
+  return raw
+}
+
+export class InputModelIndex {
+  private sources = new Map<string, Map<string, InputField>>()
+  private sourceIdByPath = new Map<string, string>()
+  private sourcePathById = new Map<string, string>()
+  private completionBySourceId = new Map<string, Readonly<{ key: string }>>()
+
+  has(sourcePath: string) {
+    return Boolean(this.sources.get(sourcePath)?.size)
+  }
+
+  unindex(sourcePath: string) {
+    this.sources.delete(sourcePath)
+    const sourceId = this.sourceIdByPath.get(sourcePath)
+    if (!sourceId) return
+    this.sourceIdByPath.delete(sourcePath)
+    this.sourcePathById.delete(sourceId)
+    this.completionBySourceId.delete(sourceId)
+  }
+
+  replace(
+    source: Source,
+    controls: readonly InputControl[],
+    completion?: Readonly<{ key: string }>,
+  ) {
+    this.unindex(source.path)
+    const fields = new Map<string, InputField>()
+    for (const control of controls) this.add(fields, source.path, control)
+    if (!fields.size && !completion) return
+    if (fields.size) this.sources.set(source.path, fields)
+    this.sourceIdByPath.set(source.path, source.id)
+    this.sourcePathById.set(source.id, source.path)
+    if (completion) this.completionBySourceId.set(source.id, completion)
+  }
+
+  private add(
+    fields: Map<string, InputField>,
+    sourcePath: string,
+    control: InputControl,
+  ) {
+    let field = fields.get(control.name)
+    if (!field) {
+      field = isChoice(control)
+        ? {
+            type: control.type,
+            options: new Set(),
+            required: control.required,
+            min: control.min,
+          }
+        : { type: control.type, required: control.required }
+      fields.set(control.name, field)
+    }
+    if (field.type !== control.type) {
+      throw new Error(
+        `Input field ${control.name} in ${sourcePath} mixes ${field.type} and ${control.type}.`,
+      )
+    }
+    field.required ||= control.required
+    if (isChoice(control) && isChoiceField(field)) {
+      field.options.add(control.value)
+      field.min = Math.max(field.min, control.min)
+    }
+  }
+
+  completion(sourceId: string) {
+    return this.completionBySourceId.get(sourceId)
+  }
+
+  validateSource(sourceId: string, values: InputValues) {
+    const path = this.sourcePathById.get(sourceId)
+    if (!path) throw new Error(`No indexed Input Source ${sourceId}.`)
+    return this.validate(path, values)
+  }
+
+  validate(sourcePath: string, input: ActionInput): InputValues {
+    const fields = this.sources.get(sourcePath)
+    if (!fields?.size)
+      throw new Error(`No indexed Input fields in ${sourcePath}.`)
+    const unknown = Object.keys(input).filter(
+      (name) => name !== "_target" && !fields.has(name),
+    )
+    if (unknown.length)
+      throw new Error(`Unknown Input field: ${unknown.join(", ")}.`)
+
+    const values: InputValues = {}
+    for (const [name, field] of fields) {
+      const raw = input[name]
+      if (!isChoiceField(field)) {
+        const value = textValue(name, field.required, raw)
+        if (value != null) values[name] = value
+        continue
+      }
+      if (field.type === "radio") {
+        if (raw == null || raw === "") {
+          if (field.required)
+            throw new Error(`Input field ${name} is required.`)
+          continue
+        }
+        if (Array.isArray(raw) || !field.options.has(raw)) {
+          throw new Error(`Invalid value for Input field ${name}.`)
+        }
+        values[name] = raw
+        continue
+      }
+
+      const selected = raw == null ? [] : Array.isArray(raw) ? raw : [raw]
+      const unique = [...new Set(selected)]
+      if (unique.some((value) => !field.options.has(value))) {
+        throw new Error(`Invalid value for Input field ${name}.`)
+      }
+      if (unique.length < Math.max(field.min, field.required ? 1 : 0)) {
+        throw new Error(`Input field ${name} requires more selections.`)
+      }
+      values[name] = unique
+    }
+    return values
+  }
+}