@trypattern/sdk 0.0.0-stage → 0.1.0

package/dist/model.d.ts

@@ -0,0 +1,94 @@
+import { z } from 'zod';
+import { StoreBase } from './store.ts';
+import type { Persisted, StateOf, StateSpec } from './state.ts';
+import type { SameOnTheWire } from './wire.ts';
+type Shape = z.ZodRawShape;
+type NoInput = Record<never, never>;
+export type InputOf<S extends Shape> = keyof S extends never ? NoInput : z.output<z.ZodObject<S>>;
+export type CommandResult = void | Promise<void>;
+type Handler<S extends Shape, Result> = keyof S extends never ? () => Result : (input: InputOf<S>) => Result;
+export type RouteParams = Readonly<Record<string, string | undefined>>;
+declare const INPUT: unique symbol;
+export type Command<S extends Shape, Result extends CommandResult> = Handler<S, Result> & {
+    readonly [INPUT]: z.ZodObject<S>;
+};
+type AnyCommand = {
+    readonly [INPUT]: z.ZodType;
+};
+export type CommandOptions<S extends Shape> = {
+    input: SameOnTheWire<S>;
+};
+export declare function command<Result extends CommandResult>(run: () => Result): Command<NoInput, Result>;
+export declare function command<S extends Shape, Result extends CommandResult>(options: CommandOptions<S>, run: (input: InputOf<S>) => Result): Command<S, Result>;
+export declare function commandFromSchema(schema: z.ZodType, run: (input: never) => CommandResult): AnyCommand;
+export declare function commandsOf(model: object): Record<string, z.ZodType>;
+export declare function answerNamesOf(model: object): readonly string[];
+export declare abstract class ModelBase<State extends object, Stores, Services> extends StoreBase<State> {
+    #private;
+    protected readonly stores: Stores;
+    protected readonly app: Services;
+    constructor(stores: Stores, app: Services);
+    onPageOpen(_params: RouteParams): void | Promise<void>;
+    protected get params(): RouteParams;
+    protected initialState(): State;
+    get snapshot(): object;
+    get published(): object;
+    protected changed(): void;
+}
+type BaseMember = keyof ModelBase<object, unknown, unknown>;
+export type DerivedOf<Model> = {
+    readonly [Key in keyof Model as Key extends BaseMember ? never : Model[Key] extends (...args: never[]) => unknown ? never : Key]: Model[Key];
+};
+export type SnapshotOf<Model> = Model extends {
+    readonly state: infer State;
+} ? Readonly<State> & DerivedOf<Model> : never;
+type Fired<Command> = Command extends (...args: infer Input) => unknown ? (...args: Input) => void : never;
+export type PublishedCommands<Model> = {
+    readonly [Key in CommandKeys<Model>]: Fired<Model[Key]>;
+};
+export type PublishedOf<Model> = SnapshotOf<Model> & PublishedCommands<Model>;
+export type ModelSnapshots<Models> = {
+    [Key in keyof Models]: SnapshotOf<Models[Key]>;
+};
+export declare function modelSnapshotsOf<Models extends Record<string, {
+    readonly snapshot: object;
+}>>(models: Models): ModelSnapshots<Models>;
+export type ModelConfig<S extends StateSpec, P extends readonly (keyof S & string)[]> = {
+    state?: S;
+    persist?: P;
+};
+export type ModelClass<Registry, Services, S extends StateSpec, P extends readonly (keyof S & string)[]> = (abstract new (stores: Registry, app: Services, device: Persisted) => ModelBase<StateOf<S>, Registry, Services>) & {
+    readonly config: ModelConfig<S, P>;
+};
+export declare function defineModel<Registry, Services>(): <S extends StateSpec = Record<never, never>, const P extends readonly (keyof S & string)[] = []>(config?: ModelConfig<S, P>) => ModelClass<Registry, Services, S, P>;
+export type AnyModel = ModelBase<object, unknown, unknown>;
+export type ModelClassLike = new (stores: never, app: never, device: Persisted) => AnyModel;
+export type Instances<Classes extends Record<string, ModelClassLike>> = {
+    [Key in keyof Classes]: InstanceType<Classes[Key]>;
+};
+export declare function createModels<Classes extends Record<string, ModelClassLike>>(classes: Classes, stores: object, services: object, persistedFor: (model: string) => Persisted): Instances<Classes>;
+export type CommandKeys<Model> = {
+    [Key in keyof Model]: Model[Key] extends AnyCommand ? Key : never;
+}[keyof Model];
+type ShapeOf<Value> = Value extends {
+    readonly [INPUT]: z.ZodObject<infer S>;
+} ? S : never;
+export type MessagesOf<Models extends Record<string, object>> = {
+    [Group in keyof Models & string]: {
+        [Name in CommandKeys<Models[Group]> & string]: {
+            type: `${Group}.${Name}`;
+        } & InputOf<ShapeOf<Models[Group][Name]>>;
+    }[CommandKeys<Models[Group]> & string];
+}[keyof Models & string];
+export type Message = {
+    readonly type: string;
+};
+export declare function splitType(type: string): {
+    group: string;
+    name: string;
+};
+export declare function parseMessage<Parsed extends Message>(raw: unknown, models: Readonly<Record<string, object>>): Parsed | {
+    error: string;
+};
+export declare function sendMessage(models: Readonly<Record<string, object>>, { type, ...input }: Message): Promise<void>;
+export {};

package/dist/model.js

@@ -0,0 +1,243 @@
+var _a;
+import { z } from 'zod';
+import { PageStore } from "./page.js";
+import { StoreBase, isDevelopment, keepEqualParts, mergeReads, plainJsonProblem, readsAreCurrent, tracked, whileBuilding } from "./store.js";
+import { restore } from "./state.js";
+const INPUT = Symbol('pattern.commandInput');
+export function command(first, second) {
+    const run = typeof first === 'function' ? first : second;
+    if (typeof run !== 'function')
+        throw new Error('command() needs a handler');
+    const options = typeof first === 'function' ? {} : first;
+    const shape = typeof options === 'object' && options !== null
+        ? Reflect.get(options, 'input')
+        : undefined;
+    return Object.assign((input) => run(input), {
+        [INPUT]: z.object((shape ?? {}))
+    });
+}
+export function commandFromSchema(schema, run) {
+    return Object.assign((input) => run(input), {
+        [INPUT]: schema
+    });
+}
+function isCommand(value) {
+    return typeof value === 'function' && INPUT in value;
+}
+export function commandsOf(model) {
+    const found = {};
+    for (const [name, value] of Object.entries(model)) {
+        if (isCommand(value))
+            found[name] = value[INPUT];
+    }
+    return found;
+}
+function sameEntries(previous, next) {
+    const previousKeys = Object.keys(previous);
+    const nextKeys = Object.keys(next);
+    return (previousKeys.length === nextKeys.length &&
+        nextKeys.every((key) => Object.is(Reflect.get(previous, key), Reflect.get(next, key))));
+}
+const answerNames = new WeakMap();
+export function answerNamesOf(model) {
+    return answerNames.get(model) ?? [];
+}
+function getterOf(instance, name) {
+    let prototype = Object.getPrototypeOf(instance);
+    while (prototype !== null) {
+        const getter = Object.getOwnPropertyDescriptor(prototype, name)?.get;
+        if (getter !== undefined)
+            return getter;
+        prototype = Object.getPrototypeOf(prototype);
+    }
+    return undefined;
+}
+export class ModelBase extends StoreBase {
+    stores;
+    app;
+    #memos = new Map();
+    #snapshot;
+    #published;
+    #isDirty = true;
+    constructor(stores, app) {
+        super();
+        this.stores = stores;
+        this.app = app;
+        const answers = this.#derived();
+        answerNames.set(this, answers);
+        for (const derived of answers) {
+            const compute = getterOf(this, derived);
+            if (compute === undefined)
+                continue;
+            Object.defineProperty(this, derived, {
+                configurable: true,
+                enumerable: false,
+                get: () => this.#evaluate(derived, compute)
+            });
+        }
+        for (const store of Object.values(stores)) {
+            store.subscribe(() => this.changed());
+        }
+    }
+    onPageOpen(_params) {
+        return undefined;
+    }
+    get params() {
+        const page = Reflect.get(this.stores, 'page');
+        return page instanceof PageStore ? page.state.params : {};
+    }
+    initialState() {
+        throw new Error(`${this.constructor.name} must extend Model({ state }) so its first state comes from the config`);
+    }
+    get snapshot() {
+        if (this.#snapshot === undefined || this.#isDirty) {
+            const next = this.#buildSnapshot();
+            const kept = this.#snapshot !== undefined && sameEntries(this.#snapshot, next)
+                ? this.#snapshot
+                : next;
+            if (kept !== this.#snapshot)
+                this.#published = undefined;
+            this.#snapshot = kept;
+            this.#isDirty = false;
+        }
+        return this.#snapshot;
+    }
+    get published() {
+        const snapshot = this.snapshot;
+        this.#published ??= this.#buildPublished(snapshot);
+        return this.#published;
+    }
+    changed() {
+        this.#isDirty = true;
+        const previous = this.#snapshot;
+        if (this.snapshot === previous)
+            return;
+        super.changed();
+    }
+    #evaluate(name, compute) {
+        const memo = this.#memos.get(name);
+        if (memo !== undefined && readsAreCurrent(memo.reads)) {
+            mergeReads(memo.reads);
+            return memo.value;
+        }
+        const { value, reads } = whileBuilding(() => tracked(() => compute.call(this)));
+        if (isDevelopment()) {
+            this.#checkPure(name, compute, value);
+            const problem = plainJsonProblem(value, `${name}`);
+            if (problem !== undefined) {
+                throw new Error(`${this.constructor.name} must publish plain JSON from its getters, because flows compare it: ${problem}`);
+            }
+        }
+        const kept = memo === undefined ? value : keepEqualParts(memo.value, value);
+        this.#memos.set(name, { value: kept, reads });
+        mergeReads(reads);
+        return kept;
+    }
+    #checkPure(name, compute, value) {
+        const again = whileBuilding(() => tracked(() => compute.call(this)).value);
+        if (JSON.stringify(value) !== JSON.stringify(again)) {
+            throw new Error(`${this.constructor.name}.${name} gave two different answers for the same state and stores, so it is not a pure getter. Getters must not read the clock, randomness or a private field.`);
+        }
+    }
+    #buildSnapshot() {
+        const snapshot = {
+            ...this.currentState
+        };
+        for (const name of this.#derived()) {
+            snapshot[name] = Reflect.get(this, name);
+        }
+        return snapshot;
+    }
+    #buildPublished(snapshot) {
+        const published = { ...snapshot };
+        for (const [name, value] of Object.entries(this)) {
+            if (isCommand(value))
+                published[name] = value;
+        }
+        return Object.freeze(published);
+    }
+    #derived() {
+        const names = [];
+        let prototype = Object.getPrototypeOf(this);
+        while (prototype !== null && prototype !== _a.prototype) {
+            for (const [name, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(prototype))) {
+                if (descriptor.get !== undefined && !names.includes(name)) {
+                    names.push(name);
+                }
+            }
+            prototype = Object.getPrototypeOf(prototype);
+        }
+        return names;
+    }
+}
+_a = ModelBase;
+export function modelSnapshotsOf(models) {
+    return Object.fromEntries(Object.entries(models).map(([key, model]) => [key, model.snapshot]));
+}
+export function defineModel() {
+    return function Model(config = {}) {
+        const persist = config.persist ?? [];
+        class Bound extends ModelBase {
+            static config = config;
+            #device;
+            constructor(stores, app, device) {
+                super(stores, app);
+                this.#device = device;
+            }
+            initialState() {
+                return restore(config.state ?? {}, persist, this.#device);
+            }
+            set(patch) {
+                super.set(patch);
+                for (const key of persist) {
+                    if (key in patch)
+                        this.#device.write(key, this.state[key]);
+                }
+            }
+        }
+        return Bound;
+    };
+}
+export function createModels(classes, stores, services, persistedFor) {
+    const entries = Object.entries(classes).map(([key, Class]) => {
+        const create = Class;
+        return [key, new create(stores, services, persistedFor(key))];
+    });
+    return Object.fromEntries(entries);
+}
+export function splitType(type) {
+    const dot = type.indexOf('.');
+    return dot === -1
+        ? { group: '', name: type }
+        : { group: type.slice(0, dot), name: type.slice(dot + 1) };
+}
+export function parseMessage(raw, models) {
+    const specs = Object.entries(models).map(([group, model]) => [group, commandsOf(model)]);
+    const known = specs.flatMap(([group, spec]) => Object.keys(spec).map((name) => `${group}.${name}`));
+    const unknown = `Unknown command ${JSON.stringify(raw)}. Commands: ${known.join(', ')}`;
+    if (typeof raw !== 'object' || raw === null || !('type' in raw)) {
+        return { error: unknown };
+    }
+    const { type, ...input } = raw;
+    if (typeof type !== 'string')
+        return { error: unknown };
+    const { group, name } = splitType(type);
+    const schema = specs.find(([key]) => key === group)?.[1][name];
+    if (schema === undefined)
+        return { error: unknown };
+    const parsed = schema.safeParse(input);
+    if (!parsed.success) {
+        return { error: `Command ${type}: ${z.prettifyError(parsed.error)}` };
+    }
+    return { type, ...parsed.data };
+}
+export function sendMessage(models, { type, ...input }) {
+    const { group, name } = splitType(type);
+    const model = models[group];
+    const target = model === undefined ? undefined : Reflect.get(model, name);
+    if (!isCommand(target)) {
+        return Promise.reject(new Error(`Unknown command ${type}`));
+    }
+    const run = target;
+    return Promise.resolve(run(input));
+}

package/dist/page.d.ts

@@ -0,0 +1,11 @@
+import type { RouteParams } from './model.ts';
+import { StoreBase } from './store.ts';
+type PageState = {
+    page: string | null;
+    params: RouteParams;
+};
+export declare class PageStore extends StoreBase<PageState> {
+    protected initialState(): PageState;
+    moved(page: string | null, params: RouteParams): void;
+}
+export {};

package/dist/page.js

@@ -0,0 +1,9 @@
+import { StoreBase } from "./store.js";
+export class PageStore extends StoreBase {
+    initialState() {
+        return { page: null, params: {} };
+    }
+    moved(page, params) {
+        this.set({ page, params });
+    }
+}

package/dist/platform.d.ts

@@ -0,0 +1 @@
+export declare function isApplePlatform(): boolean;

package/dist/platform.js

@@ -0,0 +1,5 @@
+export function isApplePlatform() {
+    if (typeof navigator === 'undefined')
+        return false;
+    return /Mac|iPhone|iPad/.test(navigator.userAgent);
+}

package/dist/react.d.ts

@@ -0,0 +1,46 @@
+export { AppProvider, useModel } from './hooks/appContext.ts';
+export { AppFrame } from './components/AppFrame.tsx';
+export { AppearancePicker } from './components/AppearancePicker.tsx';
+export { Avatar } from './components/Avatar.tsx';
+export { Badge } from './components/Badge.tsx';
+export { Button } from './components/Button.tsx';
+export { Card } from './components/Card.tsx';
+export { CommandMenu } from './components/CommandMenu.tsx';
+export { CommandPalette } from './components/CommandPalette.tsx';
+export type { CommandMenuItem } from './components/CommandMenu.tsx';
+export { Content } from './components/Content.tsx';
+export { ContextMenu } from './components/ContextMenu.tsx';
+export { Dialog } from './components/Dialog.tsx';
+export { Divider } from './components/Divider.tsx';
+export { EmptyState } from './components/EmptyState.tsx';
+export { Form } from './components/Form.tsx';
+export { Icon } from './components/Icon.tsx';
+export { IconButton } from './components/IconButton.tsx';
+export type { IconName } from './components/icons.ts';
+export { Kbd } from './components/Kbd.tsx';
+export { Link } from './components/Link.tsx';
+export { ListRow } from './components/ListRow.tsx';
+export { LoadingRows } from './components/LoadingRows.tsx';
+export { Menu } from './components/Menu.tsx';
+export type { MenuEntry } from './components/MenuItems.tsx';
+export type { SidebarLink } from './components/Sidebar.tsx';
+export type { Placement } from './components/Placement.ts';
+export { PropertyRow } from './components/PropertyRow.tsx';
+export { Row } from './components/Row.tsx';
+export { Screen } from './components/Screen.tsx';
+export { ScrollArea } from './components/ScrollArea.tsx';
+export { SegmentedControl } from './components/SegmentedControl.tsx';
+export type { SegmentedOption } from './components/SegmentedControl.tsx';
+export { Select } from './components/Select.tsx';
+export type { SelectOption } from './components/Select.tsx';
+export { SettingsRow } from './components/SettingsRow.tsx';
+export { SignInScreen } from './components/SignInScreen.tsx';
+export { Skeleton } from './components/Skeleton.tsx';
+export type { SpaceName } from './components/spacing.ts';
+export { Spinner } from './components/Spinner.tsx';
+export { Stack } from './components/Stack.tsx';
+export { Switch } from './components/Switch.tsx';
+export { Text } from './components/Text.tsx';
+export { TextField } from './components/TextField.tsx';
+export { Toaster } from './components/Toaster.tsx';
+export { Tooltip } from './components/Tooltip.tsx';

package/dist/react.js

@@ -0,0 +1,38 @@
+export { AppProvider, useModel } from "./hooks/appContext.js";
+export { AppFrame } from "./components/AppFrame.js";
+export { AppearancePicker } from "./components/AppearancePicker.js";
+export { Avatar } from "./components/Avatar.js";
+export { Badge } from "./components/Badge.js";
+export { Button } from "./components/Button.js";
+export { Card } from "./components/Card.js";
+export { CommandMenu } from "./components/CommandMenu.js";
+export { CommandPalette } from "./components/CommandPalette.js";
+export { Content } from "./components/Content.js";
+export { ContextMenu } from "./components/ContextMenu.js";
+export { Dialog } from "./components/Dialog.js";
+export { Divider } from "./components/Divider.js";
+export { EmptyState } from "./components/EmptyState.js";
+export { Form } from "./components/Form.js";
+export { Icon } from "./components/Icon.js";
+export { IconButton } from "./components/IconButton.js";
+export { Kbd } from "./components/Kbd.js";
+export { Link } from "./components/Link.js";
+export { ListRow } from "./components/ListRow.js";
+export { LoadingRows } from "./components/LoadingRows.js";
+export { Menu } from "./components/Menu.js";
+export { PropertyRow } from "./components/PropertyRow.js";
+export { Row } from "./components/Row.js";
+export { Screen } from "./components/Screen.js";
+export { ScrollArea } from "./components/ScrollArea.js";
+export { SegmentedControl } from "./components/SegmentedControl.js";
+export { Select } from "./components/Select.js";
+export { SettingsRow } from "./components/SettingsRow.js";
+export { SignInScreen } from "./components/SignInScreen.js";
+export { Skeleton } from "./components/Skeleton.js";
+export { Spinner } from "./components/Spinner.js";
+export { Stack } from "./components/Stack.js";
+export { Switch } from "./components/Switch.js";
+export { Text } from "./components/Text.js";
+export { TextField } from "./components/TextField.js";
+export { Toaster } from "./components/Toaster.js";
+export { Tooltip } from "./components/Tooltip.js";

package/dist/registered.d.ts

@@ -0,0 +1,54 @@
+import type { AppSnapshotShape, ModelServicesOf, NavigateCommand, PressKeyCommand, StoreClasses, StoreInstances, StoresOf } from './app.ts';
+import { z } from 'zod';
+import type { Action, DefineActions } from './actions.ts';
+import type { Instances, MessagesOf, ModelClassLike, ModelSnapshots } from './model.ts';
+import type { BUILT_IN_GROUPS } from './builtins/actions.ts';
+import type { Account } from './builtins/Account.ts';
+import type { Palette } from './builtins/Palette.ts';
+import type { SignIn } from './builtins/SignIn.ts';
+import type { IconName } from './components/icons.ts';
+import type { PageOf, PathOf, RouteShape } from './routes.ts';
+import type { Tables } from './table.ts';
+export interface Register {
+}
+type Registered<Key extends string, Fallback> = Key extends keyof Register ? Register[Key] : Fallback;
+type Empty = Record<never, never>;
+type RegisteredModels = Registered<'models', Empty> extends infer Classes extends Record<string, ModelClassLike> ? Classes : Empty;
+type RegisteredTables = Registered<'tables', Empty> extends infer Group extends Tables ? Group : Empty;
+type RegisteredStores = Registered<'stores', Empty> extends infer Classes extends StoreClasses ? Classes : Empty;
+type RegisteredActionGroups = Registered<'actionGroups', readonly string[]> extends infer Groups extends readonly string[] ? Groups : readonly string[];
+export type AppActionGroup = RegisteredActionGroups[number] | (typeof BUILT_IN_GROUPS)[number];
+export type AppAction = Action & {
+    group: AppActionGroup;
+    icon: IconName;
+};
+type RegisteredAction = AppAction;
+type RegisteredRoutes = Registered<'routes', readonly []> extends infer Routes extends readonly RouteShape[] ? Routes : readonly [];
+type RegisteredIcons = Registered<'icons', Empty> extends infer Icons extends Record<string, unknown> ? Icons : Empty;
+export type AppIconName = keyof RegisteredIcons & string;
+export type BuiltInModels = {
+    account: typeof Account;
+    palette: typeof Palette;
+    signIn: typeof SignIn;
+};
+export type AppModels = Instances<BuiltInModels & RegisteredModels>;
+export type AppPath = PathOf<RegisteredRoutes>;
+export type AppPage = PageOf<RegisteredRoutes>;
+export type AppCommand = MessagesOf<AppModels> | NavigateCommand<AppPath> | PressKeyCommand;
+export type AppStores = StoresOf<RegisteredTables, StoreInstances<RegisteredStores>, RegisteredAction>;
+export type AppSnapshot = AppSnapshotShape<AppModels, AppStores, AppPage>;
+export type ActionContext = {
+    readonly page: AppPage | null;
+    readonly models: ModelSnapshots<AppModels>;
+};
+export type ModelServices = ModelServicesOf<AppPath>;
+export declare const Model: <S extends import("./state.ts").StateSpec = Record<never, never>, const P extends readonly (keyof S & string)[] = []>(config?: import("./model.ts").ModelConfig<S, P>) => import("./model.ts").ModelClass<AppStores, ModelServices, S, P>;
+export declare const defineActions: DefineActions<ActionContext, RegisteredAction, AppCommand>;
+export declare const appPath: z.ZodCustom<AppPath, AppPath>;
+type ActionInput = Pick<AppAction, 'id' | 'label' | 'group' | 'icon'> & Partial<Pick<AppAction, 'keys' | 'keywords' | 'isDanger' | 'isSearchOnly' | 'isHidden'>> & {
+    send: readonly AppCommand[];
+};
+export declare function action(input: ActionInput): AppAction & {
+    send: readonly AppCommand[];
+};
+export {};

package/dist/registered.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { bindActions } from "./actions.js";
+import { defineModel } from "./model.js";
+import { isRoutedPath } from "./routes.js";
+export const Model = defineModel();
+export const defineActions = bindActions();
+export const appPath = z.custom((value) => typeof value === 'string' && isRoutedPath(value), { error: 'Not a page in src/routes.tsx' });
+export function action(input) {
+    return {
+        keys: [],
+        keywords: '',
+        isDanger: false,
+        isSearchOnly: false,
+        isHidden: false,
+        ...input
+    };
+}

package/dist/routes.d.ts

@@ -0,0 +1,38 @@
+import type { ComponentType } from 'react';
+import type { RouteObject } from 'react-router';
+export type RouteDefinition = {
+    readonly id?: string;
+    readonly path?: string;
+    readonly index?: boolean;
+    readonly Component?: ComponentType;
+    readonly children?: readonly RouteDefinition[];
+};
+type IdsOf<Route> = (Route extends {
+    readonly id: infer Id extends string;
+} ? Id : never) | (Route extends {
+    readonly children: infer Children;
+} ? PageOf<Children> : never);
+export type PageOf<Routes> = Routes extends readonly (infer Route)[] ? IdsOf<Route> : never;
+export type RouteShape = {
+    readonly id?: string;
+    readonly path?: string;
+    readonly index?: boolean;
+    readonly Component?: unknown;
+    readonly children?: readonly RouteShape[];
+};
+export declare function defineRoutes<const Routes extends readonly RouteShape[]>(routes: Routes): Routes;
+export declare function pageIds(routes: readonly RouteDefinition[]): readonly string[];
+export declare function registerRoutes(routes: readonly RouteDefinition[]): void;
+export declare function isRoutedPath(path: string): boolean;
+export declare function routeObjects(routes: readonly RouteDefinition[]): RouteObject[];
+type Joined<Parent extends string, Path extends string> = Path extends `/${string}` ? Path : Parent extends '' | '/' ? `/${Path}` : `${Parent}/${Path}`;
+type Pattern<Path extends string> = Path extends `${infer Head}:${infer Rest}` ? Rest extends `${string}/${infer Tail}` ? `${Head}${string}/${Pattern<Tail>}` : `${Head}${string}` : Path;
+type PathsOfRoute<Route, Parent extends string> = Route extends {
+    readonly path: infer Path extends string;
+} ? (Path extends '*' ? never : Pattern<Joined<Parent, Path>>) | (Route extends {
+    readonly children: infer Children;
+} ? PathOf<Children, Joined<Parent, Path>> : never) : Route extends {
+    readonly children: infer Children;
+} ? PathOf<Children, Parent> : never;
+export type PathOf<Routes, Parent extends string = ''> = Routes extends readonly (infer Route)[] ? PathsOfRoute<Route, Parent> : never;
+export {};

package/dist/routes.js

@@ -0,0 +1,21 @@
+import { matchRoutes } from 'react-router';
+export function defineRoutes(routes) {
+    return routes;
+}
+export function pageIds(routes) {
+    return routes.flatMap((route) => [
+        ...(route.id === undefined ? [] : [route.id]),
+        ...pageIds(route.children ?? [])
+    ]);
+}
+let registeredRoutes = [];
+export function registerRoutes(routes) {
+    registeredRoutes = routeObjects(routes);
+}
+export function isRoutedPath(path) {
+    const match = matchRoutes(registeredRoutes, path)?.at(-1);
+    return match !== undefined && match.route.path !== '*';
+}
+export function routeObjects(routes) {
+    return routes;
+}

package/dist/rules/checkAllFiles.d.ts

@@ -0,0 +1 @@
+export {};