@karagoz/hayali 0.0.0-stage → 0.6.1

package/dist/src/composables/useLessonPosition.d.ts

@@ -0,0 +1,30 @@
+import { Ref } from 'vue';
+import type { MaybeRefOrGetter } from 'vue';
+import type { Chapter, Lesson, Position, Step } from '../types';
+export interface StepGroupEntry {
+    position: Position;
+    title: string;
+}
+export interface StepGroup {
+    chapterId: string;
+    /** Undefined when the lesson has a single chapter (flattened). */
+    title?: string;
+    steps: StepGroupEntry[];
+}
+/** First step of the first non-empty chapter; blank IDs for a lesson with no steps. */
+export declare const firstPosition: (lesson: Lesson) => Position;
+/** Whether `target` names an existing step (step IDs are only unique within a chapter). */
+export declare const hasPosition: (lesson: Lesson, target: Position) => boolean;
+/**
+ * Lesson traversal over a `{ chapterId, stepId }` position.
+ * @param lesson
+ * @param position the `v-model` ref; written through by `goTo`
+ */
+export declare const useLessonPosition: (lesson: MaybeRefOrGetter<Lesson>, position: Ref<Position>) => {
+    chapter: import("vue").ComputedRef<Chapter | undefined>;
+    step: import("vue").ComputedRef<Step | undefined>;
+    prev: import("vue").ComputedRef<Position | undefined>;
+    next: import("vue").ComputedRef<Position | undefined>;
+    groups: import("vue").ComputedRef<StepGroup[]>;
+    goTo: (target: Position) => void;
+};

package/dist/src/composables/useLessonReset.d.ts

@@ -0,0 +1,34 @@
+import type { MaybeRefOrGetter } from 'vue';
+import type { AdjustmentsTree, Lesson, Position } from '../types';
+/** The slice of WebContainer's `fs` this composable needs; injectable for tests. */
+export interface LessonFs {
+    watch(path: string, options: {
+        recursive: boolean;
+    }, listener: (event: string, filename: string | Uint8Array | null) => void): {
+        close(): void;
+    };
+    mount(tree: AdjustmentsTree): Promise<unknown>;
+    rm(path: string, options?: {
+        recursive?: boolean;
+        force?: boolean;
+    }): Promise<unknown>;
+}
+export type Tier = 'A' | 'B';
+/**
+ * Tier A (immutable) / tier B (resettable) tracking, dirty flag, confirm gate and reset-on-navigate.
+ * @param options.fs WebContainer-shaped `fs`
+ * @param options.lesson
+ */
+export declare const useLessonReset: (options: {
+    fs: LessonFs;
+    lesson: MaybeRefOrGetter<Lesson>;
+}) => {
+    tierOf: (path: string) => Tier;
+    dirty: import("vue").Ref<boolean, boolean>;
+    requiresConfirm: import("vue").ComputedRef<boolean>;
+    current: import("vue").Ref<Position | undefined, Position | undefined>;
+    boot: (position: Position) => Promise<void>;
+    reset: (from: Position, to: Position) => Promise<void>;
+    navigate: (to: Position, confirm: () => boolean | Promise<boolean>) => Promise<boolean>;
+    dispose: () => void;
+};

package/dist/src/composables/useStepEntry.d.ts

@@ -0,0 +1,59 @@
+import type { Ref } from 'vue';
+import type { Lesson, Position } from '../types';
+/** The slice of `useSandbox()` this composable calls; injectable for tests. */
+export interface StepEntrySandbox {
+    editorTabs: {
+        tabs: Readonly<Ref<readonly {
+            id: string;
+        }[]>>;
+        open(id: string): void;
+        close(id: string): void;
+        closeAll(): void;
+    };
+    editorViews: {
+        /** One line or one inclusive `[from, to]` range per call (the sandbox does not take lists). */
+        highlightLines(lines: number | [from: number, to: number], path: string, options: {
+            open: false;
+        }): Promise<void> | void;
+        goToLine(line: number, path: string, options: {
+            focus: false;
+        }): Promise<void>;
+        clearAllHighlightedLines(): void;
+    };
+    preview: {
+        navigate(path: string): void;
+        /** Reload the current page, e.g. after the files under it changed. */
+        reload(): Promise<void> | void;
+        /** Current preview path. */
+        path: Readonly<Ref<string>>;
+        /** Empty until the dev server is ready. */
+        url: Readonly<Ref<string>>;
+    };
+}
+/** The slice of `useLessonReset()` this composable calls. */
+export interface StepEntryReset {
+    dirty: Readonly<Ref<boolean>>;
+    navigate(to: Position, confirm: () => boolean | Promise<boolean>): Promise<boolean>;
+}
+/**
+ * Owns navigation (single-flight: confirm, reset, position) and the step-entry sequence that follows it: clear
+ * highlights, close/open tabs, highlight, go to a line, then the preview. Everything is derived from the entered step
+ * alone; nothing is inherited from the previous one. Bad directives are skipped with a dev warning, never thrown.
+ */
+export declare const useStepEntry: (options: {
+    lesson: () => Lesson;
+    position: Readonly<Ref<Position>>;
+    /** Writes the new position (after a successful reset). */
+    goTo: (to: Position) => void;
+    reset: StepEntryReset;
+    confirm: () => boolean | Promise<boolean>;
+    sandbox: StepEntrySandbox;
+    /** Whether the Sandbox pane is visible (always true on the side-by-side layout). */
+    sandboxVisible: Readonly<Ref<boolean>>;
+    /** How long to wait for an editor view before skipping a go-to. */
+    viewTimeoutMs?: number;
+}) => {
+    navigating: Ref<boolean, boolean>;
+    navigate: (target: Position) => Promise<void>;
+    enterInitial: () => Promise<void>;
+};

package/dist/src/composables/useStepLocks.d.ts

@@ -0,0 +1,24 @@
+import type { SandboxOptions } from '@karagoz/sandbox';
+import type { MaybeRefOrGetter } from 'vue';
+import type { Lesson, PathPattern, Position } from '../types';
+type ExplorerOptions = SandboxOptions['explorer'];
+/** The slice of `useSandbox().setOption` this composable needs; injectable for tests. */
+export type SetExplorerOption = (key: 'explorer', setter: (old: ExplorerOptions) => ExplorerOptions) => void;
+/**
+ * Lesson patterns are gitignore-style and relative to the project root, while the sandbox explorer matches
+ * `./`-prefixed paths. Anchor patterns containing a slash to `./` and let slash-less ones match at any depth.
+ */
+export declare const toSandboxPattern: (pattern: PathPattern) => string;
+/**
+ * Keeps the sandbox explorer's readonly patterns in sync with the current step's locks (plus the lesson's
+ * immutable tier). Readonly is UI-only: it never blocks `container.fs` writes, so locked files still count as dirty.
+ * @param options.lesson
+ * @param options.position current step
+ * @param options.setOption `useSandbox().setOption`
+ */
+export declare const useStepLocks: (options: {
+    lesson: MaybeRefOrGetter<Lesson>;
+    position: MaybeRefOrGetter<Position>;
+    setOption: SetExplorerOption;
+}) => import("vue").ComputedRef<string[]>;
+export {};

package/dist/src/examples/DefaultExample.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/src/examples/ParserExample.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;