@dxos/plugin-illustrator 0.10.0 → 0.11.0

package/dist/types/src/containers/SketchCard/SketchCard.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SketchCard.d.ts","sourceRoot":"","sources":["../../../../../src/containers/SketchCard/SketchCard.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,OAAO,CAAC;AAG1B,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAIvD,OAAO,EAA2B,KAAK,MAAM,EAAE,MAAM,QAAQ,CAAC;AAE9D,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,eAAe,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;mCAG7C,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,eAAe;;;;eAwBhE,UAAU"}

package/dist/types/src/containers/SketchCard/index.d.ts

@@ -1,2 +0,0 @@
-export * from './SketchCard';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/src/containers/SketchCard/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/containers/SketchCard/index.ts"],"names":[],"mappings":"AAIA,cAAc,cAAc,CAAC"}

package/dist/types/src/skills/sketch-skill.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sketch-skill.d.ts","sourceRoot":"","sources":["../../../../src/skills/sketch-skill.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,EAAY,MAAM,eAAe,CAAC;AA4DhD,QAAA,MAAM,KAAK,EAAE,KAAK,CAAC,UAGlB,CAAC;eAEa,KAAK"}

package/dist/types/src/types/Sketch.d.ts

@@ -1,50 +0,0 @@
-import * as Schema from 'effect/Schema';
-import { Obj, Ref, Type } from '@dxos/echo';
-declare const Sketch_base: Type.ObjClass<Sketch, {
-    readonly name?: string | undefined;
-    readonly canvas: import("@dxos/echo/internal").Ref<Obj.Unknown>;
-}, {}>;
-/**
- * Base Sketch object. Renderer-specific canvas data lives in a separate referenced object.
- * Unifies all canvas renderers (tldraw, excalidraw, ...) under one typename so they share
- * graph node, create flow, and shared surface scaffolding.
- */
-export declare class Sketch extends Sketch_base {
-}
-/**
- * Variant-narrowed reference to a Sketch.
- *
- * Encodes — at the type level — that the canvas ref points to a specific canvas type.
- * Runtime narrowing is performed by `loadSketch(ref, canvasType)` which validates and
- * returns the resolved Sketch together with its typed canvas.
- *
- * @example
- * ```ts
- * input: Schema.Struct({
- *   sketch: SketchRef(Tldraw.Canvas),
- * }),
- * // handler:
- * const { sketch, canvas } = yield* loadSketch(input.sketch, Tldraw.Canvas);
- * // `canvas` is typed as Tldraw.Canvas.
- * ```
- */
-export type SketchRef<_V> = Ref.Ref<Sketch>;
-export declare const SketchRef: <S extends Type.AnyObj>(_canvasType: S) => Schema.Schema<SketchRef<Type.InstanceType<S>>, any, never>;
-/**
- * Build a base `Sketch` object referencing the given canvas ECHO object.
- *
- * The canvas is stored as a `Ref` so the renderer-specific data (e.g. `Tldraw.Canvas`,
- * `Excalidraw.Canvas`) lives as its own ECHO object alongside the Sketch.
- *
- * @param name Optional display name shown in the graph node and Properties form.
- * @param canvas Renderer-specific canvas object.
- * @returns A new `Sketch` object with `canvas` stored as a Ref.
- */
-export declare const make: ({ name, canvas }: {
-    name?: string;
-    canvas: Obj.Unknown;
-}) => Sketch;
-/** Type guard for {@link Sketch} objects. */
-export declare const isSketch: (object: unknown) => object is Sketch;
-export {};
-//# sourceMappingURL=Sketch.d.ts.map

package/dist/types/src/types/Sketch.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Sketch.d.ts","sourceRoot":"","sources":["../../../../src/types/Sketch.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,EAAmB,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;;;;;AAI7D;;;;GAIG;AACH,qBAAa,MAAO,SAAQ,WAY3B;CAAG;AAEJ;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,SAAS,CAAC,EAAE,IAAI,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;AAE5C,eAAO,MAAM,SAAS,GAAI,CAAC,SAAS,IAAI,CAAC,MAAM,eAAe,CAAC,KAC1C,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;AAEhF;;;;;;;;;GASG;AACH,eAAO,MAAM,IAAI,qBAAsB;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,GAAG,CAAC,OAAO,CAAA;CAAE,KAAG,MAE/E,CAAC;AAEF,6CAA6C;AAC7C,eAAO,MAAM,QAAQ,WAAY,OAAO,KAAG,MAAM,IAAI,MAAwC,CAAC"}

package/dist/types/src/types/SketchOperation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SketchOperation.d.ts","sourceRoot":"","sources":["../../../../src/types/SketchOperation.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAE,QAAQ,EAAa,MAAM,YAAY,CAAC;AAMjD,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AAInC,eAAO,MAAM,MAAM;;;;;yCAYjB,CAAC;AAUH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCAaf,CAAC;AAEH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCAkBf,CAAC"}

package/dist/types/src/util/load-sketch.d.ts

@@ -1,37 +0,0 @@
-import * as Effect from 'effect/Effect';
-import { Capability } from '@dxos/app-framework';
-import { Database, Obj, type Ref, Type } from '@dxos/echo';
-import * as Sketch from '../types/Sketch';
-import { type SketchVariant } from '../types/types';
-export declare class SketchVariantMismatchError extends Error {
-    readonly sketchId: string;
-    readonly expectedTypename: string;
-    readonly actualTypename: string;
-    readonly _tag = "SketchVariantMismatchError";
-    constructor(sketchId: string, expectedTypename: string, actualTypename: string);
-}
-export declare class UnknownSketchVariantError extends Error {
-    readonly typename: string;
-    readonly _tag = "UnknownSketchVariantError";
-    constructor(typename: string);
-}
-/**
- * Loads a Sketch from a Ref and resolves its canvas, asserting the canvas matches
- * the expected type. Returns the typed pair.
- *
- * Use in operation handlers that declare `input.sketch: SketchRef<MyCanvas>`.
- */
-export declare const loadSketch: <S extends Type.AnyObj>(ref: Ref.Ref<Sketch.Sketch>, canvasType: S) => Effect.Effect<{
-    sketch: Sketch.Sketch;
-    canvas: Type.InstanceType<S>;
-}, Error, Database.Service>;
-/**
- * Loads a Sketch and resolves the variant provider matching its canvas typename.
- * Used by the renderer-agnostic read/edit operations.
- */
-export declare const resolveVariant: (ref: Ref.Ref<Sketch.Sketch>) => Effect.Effect<{
-    sketch: Sketch.Sketch;
-    canvas: Obj.Any;
-    variant: SketchVariant;
-}, Error, Database.Service | Capability.Service>;
-//# sourceMappingURL=load-sketch.d.ts.map

package/dist/types/src/util/load-sketch.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"load-sketch.d.ts","sourceRoot":"","sources":["../../../../src/util/load-sketch.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,QAAQ,EAAE,GAAG,EAAE,KAAK,GAAG,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAG3D,OAAO,KAAK,MAAM,MAAM,iBAAiB,CAAC;AAC1C,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAEpD,qBAAa,0BAA2B,SAAQ,KAAK;IAGjD,QAAQ,CAAC,QAAQ,EAAE,MAAM;IACzB,QAAQ,CAAC,gBAAgB,EAAE,MAAM;IACjC,QAAQ,CAAC,cAAc,EAAE,MAAM;IAJjC,QAAQ,CAAC,IAAI,gCAAgC;IAC7C,YACW,QAAQ,EAAE,MAAM,EAChB,gBAAgB,EAAE,MAAM,EACxB,cAAc,EAAE,MAAM,EAGhC;CACF;AAED,qBAAa,yBAA0B,SAAQ,KAAK;IAEtC,QAAQ,CAAC,QAAQ,EAAE,MAAM;IADrC,QAAQ,CAAC,IAAI,+BAA+B;IAC5C,YAAqB,QAAQ,EAAE,MAAM,EAEpC;CACF;AAED;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,SAAS,IAAI,CAAC,MAAM,OACzC,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,cACf,CAAC,KACZ,MAAM,CAAC,MAAM,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC;IAAC,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAA;CAAE,EAAE,KAAK,EAAE,QAAQ,CAAC,OAAO,CAU7F,CAAC;AAEL;;;GAGG;AACH,eAAO,MAAM,cAAc,QACpB,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,KAC1B,MAAM,CAAC,MAAM,CACd;IAAE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC;IAAC,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC;IAAC,OAAO,EAAE,aAAa,CAAA;CAAE,EAClE,KAAK,EACL,QAAQ,CAAC,OAAO,GAAG,UAAU,CAAC,OAAO,CAYnC,CAAC"}

package/src/capabilities/react-surface.tsx

@@ -1,37 +0,0 @@
-//
-// Copyright 2026 DXOS.org
-//
-
-import * as Effect from 'effect/Effect';
-import React from 'react';
-
-import { Capabilities, Capability } from '@dxos/app-framework';
-import { Surface } from '@dxos/app-framework/ui';
-import { AppSurface } from '@dxos/app-toolkit/ui';
-
-import { SketchArticle, SketchCard } from '#containers';
-
-import { Sketch } from '../types';
-
-export default Capability.makeModule(() =>
-  Effect.succeed(
-    Capability.contributes(Capabilities.ReactSurface, [
-      Surface.create({
-        id: 'sketch',
-        filter: AppSurface.oneOf(
-          AppSurface.object(AppSurface.Article, Sketch.Sketch),
-          AppSurface.object(AppSurface.Section, Sketch.Sketch),
-          AppSurface.object(AppSurface.Slide, Sketch.Sketch),
-        ),
-        component: ({ data: { subject, attendableId, extrinsic }, role }) => (
-          <SketchArticle role={role} subject={subject} attendableId={attendableId} extrinsic={extrinsic} />
-        ),
-      }),
-      Surface.create({
-        id: 'sketchCard',
-        filter: AppSurface.object(AppSurface.CardContent, Sketch.Sketch),
-        component: ({ data, role }) => <SketchCard role={role} subject={data.subject} editable={data.editable} />,
-      }),
-    ]),
-  ),
-);

package/src/containers/SketchCard/SketchCard.tsx

@@ -1,41 +0,0 @@
-//
-// Copyright 2026 DXOS.org
-//
-
-import React from 'react';
-
-import { useCapabilities } from '@dxos/app-framework/ui';
-import { type AppSurface } from '@dxos/app-toolkit/ui';
-import { Obj, type Ref } from '@dxos/echo';
-import { useObject } from '@dxos/echo-react';
-
-import { IllustratorCapabilities, type Sketch } from '#types';
-
-export type SketchCardProps = AppSurface.ObjectCardProps<Sketch.Sketch>;
-
-/** Resolves the sketch's canvas and delegates rendering to the matching variant's card. */
-export const SketchCard = ({ role, subject: sketch, editable }: SketchCardProps) => {
-  const variants = useCapabilities(IllustratorCapabilities.VariantProvider);
-  const ref = sketch.canvas as Ref.Ref<Obj.Unknown>;
-  // Subscribe via the snapshot for load/re-render, but hand variants the LIVE object —
-  // their store adapters need `Doc.createAccessor`, which rejects snapshots.
-  const [snapshot] = useObject(ref);
-  const canvas = snapshot ? ref.target : undefined;
-
-  if (!canvas) {
-    return null;
-  }
-
-  const typename = Obj.getTypename(canvas);
-  const match = variants.find((variant) => variant.id === typename);
-  if (!match?.card) {
-    return null;
-  }
-
-  const Component = match.card;
-  return <Component sketch={sketch} canvas={canvas} role={role} editable={editable} />;
-};
-
-SketchCard.displayName = 'SketchCard';
-
-export default SketchCard;

package/src/types/Sketch.ts

@@ -1,69 +0,0 @@
-//
-// Copyright 2026 DXOS.org
-//
-
-// @import-as-namespace
-
-import * as Schema from 'effect/Schema';
-
-import { Annotation, DXN, Obj, Ref, Type } from '@dxos/echo';
-import { FormInputAnnotation, LabelAnnotation } from '@dxos/echo/Annotation';
-import { CardAnnotation, CollectionItemAnnotation } from '@dxos/schema';
-
-/**
- * Base Sketch object. Renderer-specific canvas data lives in a separate referenced object.
- * Unifies all canvas renderers (tldraw, excalidraw, ...) under one typename so they share
- * graph node, create flow, and shared surface scaffolding.
- */
-export class Sketch extends Type.makeObject<Sketch>(DXN.make('org.dxos.type.sketch', '0.1.0'))(
-  Schema.Struct({
-    name: Schema.optional(Schema.String),
-    canvas: Ref.Ref(Obj.Unknown)
-      .annotations({ description: 'Reference to the renderer-specific canvas object.' })
-      .pipe(FormInputAnnotation.set(false)),
-  }).pipe(
-    LabelAnnotation.set(['name']),
-    Annotation.IconAnnotation.set({ icon: 'ph--compass-tool--regular', hue: 'indigo' }),
-    CardAnnotation.set(true),
-    CollectionItemAnnotation.set(true),
-  ),
-) {}
-
-/**
- * Variant-narrowed reference to a Sketch.
- *
- * Encodes — at the type level — that the canvas ref points to a specific canvas type.
- * Runtime narrowing is performed by `loadSketch(ref, canvasType)` which validates and
- * returns the resolved Sketch together with its typed canvas.
- *
- * @example
- * ```ts
- * input: Schema.Struct({
- *   sketch: SketchRef(Tldraw.Canvas),
- * }),
- * // handler:
- * const { sketch, canvas } = yield* loadSketch(input.sketch, Tldraw.Canvas);
- * // `canvas` is typed as Tldraw.Canvas.
- * ```
- */
-export type SketchRef<_V> = Ref.Ref<Sketch>;
-
-export const SketchRef = <S extends Type.AnyObj>(_canvasType: S) =>
-  Ref.Ref(Sketch) as Schema.Schema<SketchRef<Type.InstanceType<S>>, any, never>;
-
-/**
- * Build a base `Sketch` object referencing the given canvas ECHO object.
- *
- * The canvas is stored as a `Ref` so the renderer-specific data (e.g. `Tldraw.Canvas`,
- * `Excalidraw.Canvas`) lives as its own ECHO object alongside the Sketch.
- *
- * @param name Optional display name shown in the graph node and Properties form.
- * @param canvas Renderer-specific canvas object.
- * @returns A new `Sketch` object with `canvas` stored as a Ref.
- */
-export const make = ({ name, canvas }: { name?: string; canvas: Obj.Unknown }): Sketch => {
-  return Obj.make(Sketch, { name, canvas: Ref.make(canvas) });
-};
-
-/** Type guard for {@link Sketch} objects. */
-export const isSketch = (object: unknown): object is Sketch => Obj.instanceOf(Sketch, object);

package/src/util/load-sketch.ts

@@ -1,74 +0,0 @@
-//
-// Copyright 2026 DXOS.org
-//
-
-import * as Effect from 'effect/Effect';
-
-import { Capability } from '@dxos/app-framework';
-import { Database, Obj, type Ref, Type } from '@dxos/echo';
-
-import * as IllustratorCapabilities from '../types/IllustratorCapabilities';
-import * as Sketch from '../types/Sketch';
-import { type SketchVariant } from '../types/types';
-
-export class SketchVariantMismatchError extends Error {
-  readonly _tag = 'SketchVariantMismatchError';
-  constructor(
-    readonly sketchId: string,
-    readonly expectedTypename: string,
-    readonly actualTypename: string,
-  ) {
-    super(`Sketch ${sketchId} canvas typename mismatch: expected ${expectedTypename}, got ${actualTypename}.`);
-  }
-}
-
-export class UnknownSketchVariantError extends Error {
-  readonly _tag = 'UnknownSketchVariantError';
-  constructor(readonly typename: string) {
-    super(`No sketch variant registered for canvas type: ${typename}.`);
-  }
-}
-
-/**
- * Loads a Sketch from a Ref and resolves its canvas, asserting the canvas matches
- * the expected type. Returns the typed pair.
- *
- * Use in operation handlers that declare `input.sketch: SketchRef<MyCanvas>`.
- */
-export const loadSketch = <S extends Type.AnyObj>(
-  ref: Ref.Ref<Sketch.Sketch>,
-  canvasType: S,
-): Effect.Effect<{ sketch: Sketch.Sketch; canvas: Type.InstanceType<S> }, Error, Database.Service> =>
-  Effect.gen(function* () {
-    const sketch = yield* Database.load(ref);
-    const canvas = yield* Database.load(sketch.canvas);
-    if (!Obj.instanceOf(canvasType, canvas)) {
-      const expected = Type.getTypename(canvasType) ?? 'unknown';
-      const actual = Obj.getTypename(canvas as Obj.Any) ?? 'unknown';
-      return yield* Effect.fail(new SketchVariantMismatchError(sketch.id, expected, actual));
-    }
-    return { sketch, canvas: canvas as Type.InstanceType<S> };
-  });
-
-/**
- * Loads a Sketch and resolves the variant provider matching its canvas typename.
- * Used by the renderer-agnostic read/edit operations.
- */
-export const resolveVariant = (
-  ref: Ref.Ref<Sketch.Sketch>,
-): Effect.Effect<
-  { sketch: Sketch.Sketch; canvas: Obj.Any; variant: SketchVariant },
-  Error,
-  Database.Service | Capability.Service
-> =>
-  Effect.gen(function* () {
-    const sketch = yield* Database.load(ref);
-    const canvas = (yield* Database.load(sketch.canvas)) as Obj.Any;
-    const typename = Obj.getTypename(canvas) ?? 'unknown';
-    const variants = yield* Capability.getAll(IllustratorCapabilities.VariantProvider);
-    const variant = variants.find((entry) => entry.id === typename);
-    if (!variant) {
-      return yield* Effect.fail(new UnknownSketchVariantError(typename));
-    }
-    return { sketch, canvas, variant };
-  });