Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

7.6 KB
Raw Blame
import type { EditorControls } from '@core/component/LexicalMarkdown/builder/types';
import ArrowsOutIcon from '@icon/system/regular/arrows-out.svg';
import XIcon from '@icon/system/regular/x.svg';
import { PropertyValuePill } from '@property/component/PropertyValuePill';
import { Button, EntityComposer, ToggleSwitch } from '@ui';
import { $getRoot } from 'lexical';
import { For, onMount, Show } from 'solid-js';
import { ProjectDescriptionComposer } from '../components/project-description-composer';
import { useProjectsContext } from '../context/projects-context';
import {
  createProjectComposer,
  type ProjectComposerDraft,
  type ProjectComposerSubmission,
} from '../primitives/create-project';
import { withProjectPropertyValue } from '../primitives/property-draft';

export function CreateProject(props: {
  initialDraft?: ProjectComposerDraft;
  onClose(): void;
  /** The server creates the project after the host has closed the composer. */
  onSubmit(submission: ProjectComposerSubmission): void;
  onContinueInSplit?(draft: ProjectComposerDraft): void;
}) {
  const context = useProjectsContext();
  const definitions = context.createPropertyDefinitionsSource();
  const composer = createProjectComposer(
    context.createCommands(),
    props.initialDraft
  );
  let titleInput: HTMLInputElement | undefined;
  let description: EditorControls | undefined;
  onMount(() => titleInput?.focus());
  const focusDescriptionStart = () => {
    const editor = description?.getLexical();
    if (!editor) return;
    editor.update(() => $getRoot().getFirstChild()?.selectStart());
    editor.focus();
  };
  const submit = () => {
    const submission = composer.submit();
    if (submission) props.onSubmit(submission);
  };

  return (
    <form
      class="h-full min-h-0"
      aria-label="New project"
      onSubmit={(event) => {
        event.preventDefault();
        submit();
      }}
      onKeyDown={(event) => {
        if (
          event.key === 'Enter' &&
          (event.metaKey || event.ctrlKey) &&
          !event.isComposing
        ) {
          event.preventDefault();
          event.stopPropagation();
          submit();
        }
      }}
    >
      <EntityComposer.Root>
        <EntityComposer.Header>
          <div class="flex-1 flex items-center">
            <Show when={props.onContinueInSplit}>
              <Button
                variant="ghost"
                tabIndex={-1}
                aria-label="Continue editing in split"
                tooltip="Continue editing in split"
                size="icon-md"
                disabled={composer.pending()}
                onClick={() => props.onContinueInSplit?.(composer.snapshot())}
              >
                <ArrowsOutIcon class="size-4 shrink-0 pointer-events-none" />
              </Button>
            </Show>
          </div>
          <Show
            when={
              composer.name() ||
              composer.description().trim() ||
              composer.drafts().size > 0
            }
          >
            <Button
              tabIndex={-1}
              tooltip="Clear Draft"
              size="xs"
              variant="secondary"
              disabled={composer.pending()}
              onClick={() => {
                composer.clear();
                description?.clear();
                titleInput?.focus();
              }}
            >
              Clear Draft
            </Button>
          </Show>
          <Button
            variant="ghost"
            tabIndex={-1}
            aria-label="Close"
            tooltip="Close"
            size="icon-md"
            disabled={composer.pending()}
            onClick={props.onClose}
          >
            <XIcon class="size-4 shrink-0 pointer-events-none" />
          </Button>
        </EntityComposer.Header>
        <EntityComposer.Main class="min-h-28 justify-between">
          <EntityComposer.Title>
            <input
              ref={titleInput}
              autofocus
              aria-label="Project name"
              placeholder="Project name"
              class="ph-no-capture w-full min-w-0 text-xl/7 font-medium outline-none bg-transparent placeholder:text-ink-placeholder"
              value={composer.name()}
              required
              disabled={composer.pending()}
              onInput={(event) => composer.setName(event.currentTarget.value)}
              onKeyDown={(event) => {
                if (
                  event.isComposing ||
                  event.metaKey ||
                  event.ctrlKey ||
                  event.shiftKey ||
                  event.altKey ||
                  (event.key !== 'Enter' && event.key !== 'ArrowDown')
                ) {
                  return;
                }
                event.preventDefault();
                focusDescriptionStart();
              }}
            />
          </EntityComposer.Title>
          <EntityComposer.Body>
            <ProjectDescriptionComposer
              initialValue={composer.description()}
              disabled={composer.pending()}
              onChange={composer.setDescription}
              onSubmit={submit}
              onLeaveStart={() => titleInput?.focus()}
              ref={(controls) => {
                description = controls;
              }}
            />
          </EntityComposer.Body>
          <div>
            <EntityComposer.Properties>
              <For each={definitions.properties()}>
                {(property) => (
                  <PropertyValuePill
                    variant="secondary"
                    size="xs"
                    property={withProjectPropertyValue(
                      property,
                      composer.drafts().get(property.propertyDefinitionId)
                        ?.value
                    )}
                    canEdit={!composer.pending()}
                    entitySelfFilter={{ entityType: 'INITIATIVE' }}
                    onSave={async (_, value) => {
                      composer.saveDraft(property, value);
                    }}
                  />
                )}
              </For>
            </EntityComposer.Properties>
            <Show when={definitions.loading()}>
              <p role="status" class="text-xs text-ink-muted">
                Loading properties…
              </p>
            </Show>
            <Show when={definitions.error()}>
              <p role="status" class="text-xs text-ink-muted">
                Properties are unavailable. You can set them after creating the
                project.
              </p>
            </Show>
          </div>
        </EntityComposer.Main>
        <Show when={composer.error()}>
          {(error) => (
            <p
              role="alert"
              class="border-t border-edge-muted px-2 pt-3 text-sm text-failure"
            >
              {error()}
            </p>
          )}
        </Show>
        <EntityComposer.Footer class="items-center flex-wrap">
          <ToggleSwitch
            class="shrink-0 ml-0.5"
            checked={composer.shareWithTeam()}
            disabled={composer.pending()}
            onChange={composer.setShareWithTeam}
            label="Share with my team"
            labelClass="text-xs text-ink-muted font-normal whitespace-nowrap"
          />
          <EntityComposer.Submit
            type="submit"
            variant="primary"
            size="sm"
            class="ml-auto"
            hasContent={Boolean(composer.name().trim())}
            disabled={composer.pending() || !composer.name().trim()}
          >
            Create Project
          </EntityComposer.Submit>
        </EntityComposer.Footer>
      </EntityComposer.Root>
    </form>
  );
}