@sealcode/sealgen 0.18.8 → 0.19.0

package/@types/page/mountable-with-fields.sync-conflict-20250918-222044-TFDLWFG.d.ts

@@ -0,0 +1,42 @@
+import { ShapeToType } from "@sealcode/ts-predicates";
+import { Context } from "koa";
+import { FlatTemplatable } from "tempstream";
+import { FieldMessages, FormControl, FormControlContext } from "../forms/controls/form-control.js";
+import type { FieldsToShape, FormField } from "../forms/fields/field.js";
+import type { FormDataValue, FormMessage, FormData } from "../forms/form-types.js";
+import { Mountable } from "./mountable.js";
+export type PageErrorMessage = {
+    type: "access" | "internal";
+    message: string;
+};
+export type Fields = Record<string, FormField<boolean, any>>;
+type Resolved<T> = T extends Promise<infer X> ? X : never;
+type ParsedValue<T extends FormField> = Resolved<ReturnType<T["getParsedValue"]>>["parsed"];
+export declare abstract class MountableWithFields<F extends Fields = Fields> extends Mountable {
+    fields: F;
+    field_names_prefix: string;
+    form_id: string;
+    abstract controls: FormControl[];
+    constructor();
+    init(): void;
+    makeFormControlContext(ctx: Context, data: FormData, validate: boolean, field_messages: FieldMessages, field_name_prefix?: string, form_id?: string): FormControlContext;
+    validateValues(_ctx: Context, _data: Record<string, FormDataValue>): Promise<{
+        valid: boolean;
+        error: string;
+    }>;
+    getInitialValues(_ctx: Context): Promise<Record<string, FormDataValue>>;
+    validate(ctx: Context, values: Record<string, FormDataValue>): Promise<{
+        valid: boolean;
+        field_errors: Partial<Record<keyof Fields, string>>;
+        form_messages: FormMessage[];
+    }>;
+    renderControls(fctx: FormControlContext): FlatTemplatable;
+    renderError(_: Context, error: PageErrorMessage): Promise<FlatTemplatable>;
+    renderMessages(_: Context, data: FormData<keyof Fields>): FlatTemplatable;
+    abstract extractRawValues(ctx: Context): Promise<Record<string, FormDataValue>>;
+    getParsedValues(ctx: Context): Promise<{
+        [field in keyof F]: F[field] extends FormField<true> ? Exclude<ParsedValue<F[field]>, null> : ParsedValue<F[field]>;
+    }>;
+    getDatabaseValues(ctx: Context): Promise<ShapeToType<FieldsToShape<F>>>;
+}
+export {};

package/@types/page/mountable.d.sync-conflict-20250918-184306-TFDLWFG.ts

@@ -0,0 +1,10 @@
+import Router from "@koa/router";
+import { Context } from "koa";
+export declare abstract class Mountable {
+    init(): void;
+    abstract mount(router: Router, path: string): void;
+    abstract canAccess(ctx: Context): Promise<{
+        canAccess: boolean;
+        message: string;
+    }>;
+}

package/@types/page/page.d.sync-conflict-20250918-184320-TFDLWFG.ts

@@ -0,0 +1,18 @@
+import Router from "@koa/router";
+import { Context } from "koa";
+import { FlatTemplatable } from "tempstream";
+import type { FormDataValue } from "../forms/form-types.js";
+import { Fields, MountableWithFields, PageErrorMessage } from "./mountable-with-fields.js";
+import { PagePropsParser } from "./props-parser.js";
+export declare abstract class Page<F extends Fields = Record<string, never>> extends MountableWithFields<F> {
+    propsParser: PagePropsParser<Record<keyof Fields, unknown>>;
+    controls: never[];
+    mount(router: Router, path: string): void;
+    canAccess(_: Context): Promise<{
+        canAccess: boolean;
+        message: string;
+    }>;
+    renderError(_: Context, error: PageErrorMessage): Promise<FlatTemplatable>;
+    abstract render(ctx: Context): Promise<FlatTemplatable>;
+    extractRawValues(ctx: Context): Promise<Record<string, FormDataValue>>;
+}

package/@types/page/props-parser.d.sync-conflict-20250918-184305-TFDLWFG.ts

@@ -0,0 +1,15 @@
+import { Context } from "koa";
+import { FormDataValue } from "../forms/form-types.js";
+import type { BasePageProps } from "./list.js";
+export type EncodedProps = Record<string, unknown>;
+export declare abstract class PagePropsParser<PropsType> {
+    abstract decode(ctx: Context): Record<string, FormDataValue>;
+    abstract encode(props: Record<string, FormData>): EncodedProps;
+    abstract getHTMLInputName(prop_name: string): string;
+    overwriteProp(ctx: Context, new_props: Partial<PropsType>): EncodedProps;
+}
+export declare class AllQueryParams<PropsType extends BasePageProps> extends PagePropsParser<PropsType> {
+    decode(ctx: Context): Record<string, FormDataValue>;
+    encode(props: PropsType): Record<string, unknown>;
+    getHTMLInputName(prop_name: string): string;
+}

package/@types/page/props-parser.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 import { Context } from "koa";
 import { FormDataValue } from "../forms/form-types.js";
 import type { BasePageProps } from "./list.js";

package/@types/page/stateful-page.d.sync-conflict-20250918-184326-TFDLWFG.ts

@@ -0,0 +1,62 @@
+import Router from "@koa/router";
+import { Context } from "koa";
+import { Templatable } from "tempstream";
+import { Mountable } from "./mountable.js";
+export type StatefulPageActionDescription<ActionName> = {
+    action: ActionName;
+    label?: string;
+    content?: string;
+    disabled?: boolean;
+} | ActionName;
+export type StateAndMetadata<State, Actions> = {
+    state: State;
+    inputs: Record<string, string>;
+    action: keyof Actions;
+    action_args: string;
+} | {
+    state: State;
+    inputs: Record<string, string>;
+    action: null;
+    action_args: null;
+    $: Record<string, unknown>;
+};
+export type StatefulPageActionArgument<State extends Record<string, unknown>, Args extends unknown[] = unknown[]> = {
+    ctx: Context;
+    state: State;
+    inputs: Record<string, string>;
+    args: Args;
+    page: StatefulPage<any, any>;
+};
+export type StatefulPageAction<State extends Record<string, unknown>, Args extends unknown[] = unknown[]> = (obj: StatefulPageActionArgument<State, Args>) => State | Promise<State>;
+export type ExtractStatefulPageActionArgs<X> = X extends StatefulPageAction<any, infer Args> ? Args : never;
+export declare abstract class StatefulPage<State extends Record<string, unknown>, Actions extends Record<string, StatefulPageAction<State>>> extends Mountable {
+    abstract actions: Actions;
+    abstract getInitialState(ctx: Context): State | Promise<State>;
+    abstract render(ctx: Context, state: State, inputs: Record<string, string>): Templatable | Promise<Templatable>;
+    canAccess(_ctx: Context): Promise<{
+        canAccess: boolean;
+        message: string;
+    }>;
+    constructor();
+    abstract wrapInLayout(ctx: Context, content: Templatable, state: State): Templatable;
+    wrapInForm(context: Context, state: State, content: Templatable): Promise<Templatable>;
+    extractActionAndLabel<ActionName extends keyof Actions>(action_description: StatefulPageActionDescription<ActionName>): {
+        action: string;
+        label: string;
+        content: string;
+        disabled: boolean;
+    };
+    makeActionURL<ActionName extends keyof Actions>(action_description: StatefulPageActionDescription<ActionName>, ...args: ExtractStatefulPageActionArgs<Actions[ActionName]>): string;
+    makeActionButton<ActionName extends keyof Actions>(_state: State, action_description: StatefulPageActionDescription<ActionName>, ...args: ExtractStatefulPageActionArgs<Actions[ActionName]>): string;
+    makeActionCallback<ActionName extends keyof Actions>(action_description: {
+        action: ActionName;
+        label?: string;
+    } | ActionName, ...args: ExtractStatefulPageActionArgs<Actions[ActionName]>): string;
+    rerender(): string;
+    preprocessState(values: State): Promise<State>;
+    preprocessOverrides(_context: Context, _state: State, values: Record<string, unknown>): Promise<Record<string, unknown>>;
+    serializeState(_context: Context, state: State): Promise<string>;
+    deserializeState(_context: Context, s: string): Promise<State>;
+    extractState(ctx: Context): Promise<StateAndMetadata<State, Actions>>;
+    mount(router: Router, path: string): void;
+}

package/@types/templates/shared/shared-crud-form-fields.d.sync-conflict-20250918-184306-TFDLWFG.ts

@@ -0,0 +1 @@
+export declare function sharedCrudFormFields(collection_name: string, newfilefullpath: string): Promise<string>;

package/@types/templates/shared/shared-crud-form-fields.d.ts

@@ -1,68 +1 @@
-import { ExtractedFieldInfo } from "../../utils/extract-fields-from-collection.js";
-export type FieldHandlerResult = {
-    imports: Partial<{
-        shared: string;
-        edit: string;
-    }>;
-    hide_field: boolean;
-    field: string;
-    hide_control: boolean;
-    controls: string;
-    is_required: boolean;
-    is_required_expr: string;
-    fields_var: string;
-    top_level_shared: string;
-    name: string;
-    hide_initial_value_edit: boolean;
-    initial_value_edit: Partial<{
-        main_value: string;
-        parsed_value: string;
-        fallback_value: string;
-    }> | string;
-    hide_initial_value_create: boolean;
-    initial_value_create: string;
-    pre_edit: string;
-    post_edit: string;
-    pre_create: string;
-    post_create: string;
-    sealious_value: (result: Exclude<FieldHandlerResult, "sealious_value">) => string;
-    hide_sealious_value: boolean;
-    fallback_value_sealious: string;
-    main_value_sealious: string;
-};
-export type FieldHandler<Defaults extends Partial<FieldHandlerResult>, Result extends Partial<FieldHandlerResult>> = (collection_name: string, field: ExtractedFieldInfo, importPath: (path: string) => string, defaults: Defaults, all_other_handlers: Record<string, FieldHandler<FieldHandlerResult, Partial<FieldHandlerResult>> | undefined>, fields_var?: string) => Promise<Result>;
-export declare const field_handlers: Record<Exclude<string, "default">, FieldHandler<FieldHandlerResult, Partial<FieldHandlerResult>> | undefined> & {
-    default: FieldHandler<Record<string, never>, FieldHandlerResult>;
-};
-export declare function getFieldHandler(collection_name: string, field: ExtractedFieldInfo, importPath: (path: string) => string, fields_var?: string): Promise<{
-    imports: Partial<{
-        shared: string;
-        edit: string;
-    }>;
-    hide_field: boolean;
-    field: string;
-    hide_control: boolean;
-    controls: string;
-    is_required: boolean;
-    is_required_expr: string;
-    fields_var: string;
-    top_level_shared: string;
-    name: string;
-    hide_initial_value_edit: boolean;
-    initial_value_edit: string | Partial<{
-        main_value: string;
-        parsed_value: string;
-        fallback_value: string;
-    }>;
-    hide_initial_value_create: boolean;
-    initial_value_create: string;
-    pre_edit: string;
-    post_edit: string;
-    pre_create: string;
-    post_create: string;
-    sealious_value: (result: FieldHandlerResult) => string;
-    hide_sealious_value: boolean;
-    fallback_value_sealious: string;
-    main_value_sealious: string;
-}>;
 export declare function sharedCrudFormFields(collection_name: string, newfilefullpath: string): Promise<string>;

package/@types/test_utils/test-on-real-app.d.sync-conflict-20250918-184320-TFDLWFG.ts

@@ -0,0 +1,26 @@
+import EventEmitter from "events";
+export declare const callSealgenBin: () => string;
+export declare class RealAppTest {
+    node_pid: number;
+    app_port: number;
+    mongo_port: number;
+    app_path: string;
+    container_name: string;
+    emitter: EventEmitter<[never]>;
+    static init(): Promise<RealAppTest>;
+    start(): Promise<void>;
+    close(): Promise<void>;
+    runSealgenCommand(command: string): Promise<void>;
+    build(): Promise<void>;
+    throwIfItKillsTheApp<T>(cb: () => Promise<T>): Promise<T>;
+    httpGET(path: string): Promise<{
+        status: number;
+        response: string;
+    }>;
+    httpPOST(path: string, body: Record<string, unknown>): Promise<{
+        status: number;
+        response: string;
+    }>;
+    addFile(target_path: string, content: string): Promise<void>;
+    fullURL(path: string): string;
+}

package/@types/test_utils/test-on-real-app.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 import EventEmitter from "events";
 export declare const callSealgenBin: () => string;
 export declare class RealAppTest {

package/@types/utils/extract-fields-from-collection.d.sync-conflict-20250918-184312-TFDLWFG.ts

@@ -0,0 +1,18 @@
+import { FormField } from "../forms/fields/field.js";
+export type ExtractedFieldInfo = {
+    name: string;
+    type: string;
+    target: string | null;
+    referencing_collection: string | null;
+    referencing_field: string | null;
+    intermediary_field_that_points_there: string | null;
+    is_readonly: boolean;
+    is_required: boolean;
+    subfields: {
+        name: string;
+    }[];
+};
+export type ExtractedFieldInfoWithFormField = ExtractedFieldInfo & {
+    form_field: FormField;
+};
+export default function extract_fields_from_collection(collection_name: string): Promise<ExtractedFieldInfoWithFormField[]>;

package/@types/utils/extract-fields-from-collection.d.ts

@@ -1,3 +1,4 @@
+import { FormField } from "../forms/fields/field.js";
 export type ExtractedFieldInfo = {
     name: string;
     type: string;
@@ -11,4 +12,7 @@ export type ExtractedFieldInfo = {
         name: string;
     }[];
 };
-export default function extract_fields_from_collection(collection_name: string): Promise<ExtractedFieldInfo[]>;
+export type ExtractedFieldInfoWithFormField = ExtractedFieldInfo & {
+    form_field: FormField;
+};
+export default function extract_fields_from_collection(collection_name: string): Promise<ExtractedFieldInfoWithFormField[]>;

package/@types/utils/extract-fields-from-collection.sync-conflict-20250918-222045-TFDLWFG.d.ts

@@ -0,0 +1,18 @@
+import { FormField } from "../forms/fields/field.js";
+export type ExtractedFieldInfo = {
+    name: string;
+    type: string;
+    target: string | null;
+    referencing_collection: string | null;
+    referencing_field: string | null;
+    intermediary_field_that_points_there: string | null;
+    is_readonly: boolean;
+    is_required: boolean;
+    subfields: {
+        name: string;
+    }[];
+};
+export type ExtractedFieldInfoWithFormField = ExtractedFieldInfo & {
+    form_field: FormField;
+};
+export default function extract_fields_from_collection(collection_name: string): Promise<ExtractedFieldInfoWithFormField[]>;

package/@types/utils/wrap-attributes.d.ts

@@ -0,0 +1,3 @@
+export declare function needsQuotes(str: string): boolean;
+export declare function wrapAttribute(name: string): string;
+export declare function wrapKeyName(name: string): string;

package/README.md

@@ -67,3 +67,8 @@ You can add these commands to your module's `package.json` postinstall script to
 5. If the path is already present, it doesn't add a duplicate
 
 This ensures that when your module is installed as a dependency, the parent project will automatically know where to find your controllers and styles.
+
+
+### Attributions
+
+File icon - Gnome Project

package/assets/file-icon.svg

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg height="128px" viewBox="0 0 128 128" width="128px" xmlns="http://www.w3.org/2000/svg">
+    <path d="m 28 8 h 50 l 30.042969 29.917969 v 74.058593 c 0 4.433594 -3.609375 8.023438 -8.042969 8.023438 h -72 c -4.433594 0 -8 -3.566406 -8 -8 v -96 c 0 -4.433594 3.566406 -8 8 -8 z m 0 0" fill="#f6f5f4"/>
+    <path d="m 78 8 v 22 c 0 4.433594 3.609375 7.921875 8.042969 7.921875 l 22 -0.003906 z m 0 0" fill="#deddda"/>
+</svg>

package/lib/add-crud.js

@@ -1,18 +1,16 @@
 import _locreq from "locreq";
-import prompts from "prompts";
 import { escape_url_params } from "./utils/escape-url-params.js";
+import prompts from "prompts";
 import { toKebabCase, toPascalCase } from "js-convert-case";
 import { listCollections } from "./utils/list-collections.js";
-import {
-  makeDefaultDisplayFields,
-  makeDefaultFilterFields
-} from "./templates/shared/collection-list.js";
+import { collectionListTemplate } from "./templates/shared/collection-list.js";
 import { writeFile } from "./utils/write-file.js";
-import { extractCollectionClassname } from "./generate-collections.js";
-import extract_fields_from_collection from "./utils/extract-fields-from-collection.js";
-import { getFieldHandler } from "./templates/shared/shared-crud-form-fields.js";
+import { curryImportPath, importPath } from "./utils/import-path.js";
+import { sharedCrudFormFields } from "./templates/shared/shared-crud-form-fields.js";
 import { generateRoutes } from "./generate-routes.js";
-import { formatWithPrettier } from "./utils/prettier.js";
+import { createItemFormTemplate } from "./templates/shared/collection-create-form.js";
+import { editItemFormTemplate } from "./templates/shared/collection-edit-form.js";
+import { itemDeleteTemplate } from "./templates/shared/item-delete.js";
 async function addCRUD(params, app_directory = process.cwd()) {
   const target_locreq = _locreq(app_directory);
   prompts.override(params);
@@ -29,7 +27,7 @@ async function addCRUD(params, app_directory = process.cwd()) {
     {
       type: "text",
       name: "url",
-      message: "Enter a full absolute path for the new route (for example: /admin/users/): ",
+      message: "Enter a full absolute path for the new route (for example: /admin/users/:id/edit): ",
       validate: (s) => s.trim()[0] == "/" ? true : "Should start with a '/'",
       initial: function(_, { collection }) {
         return "/" + toKebabCase(collection);
@@ -38,88 +36,81 @@ async function addCRUD(params, app_directory = process.cwd()) {
   ]);
   const collection_name = response.collection;
   const url = response.url;
+  const list_action_name = toPascalCase(collection_name) + "CRUDList";
+  const create_action_name = toPascalCase(collection_name) + "CRUDCreate";
+  const edit_action_name = toPascalCase(collection_name) + "CRUDEdit";
+  const delete_action_name = toPascalCase(collection_name) + "CRUDDelete";
   const list_path = target_locreq.resolve(
-    `src/back/routes/${escape_url_params(url)}/index.page.ts`
+    `src/back/routes/${escape_url_params(url)}/index.list.tsx`
   );
-  const [uppercase_collection, collection_fields] = await Promise.all([
-    extractCollectionClassname(
-      target_locreq.resolve(
-        "src/back/collections/" + collection_name + ".ts"
-      )
-    ),
-    extract_fields_from_collection(collection_name)
-  ]);
-  const field_handler_results = await Promise.all(
-    collection_fields.map(async (field) => {
-      return getFieldHandler(
-        collection_name,
-        field,
-        (p) => p,
-        "edit_fields"
-      );
-    })
+  const list_content = await collectionListTemplate(
+    collection_name,
+    list_action_name,
+    list_path,
+    {
+      post_import_js: `import { ${create_action_name}URL, ${edit_action_name}URL, ${delete_action_name}URL } from "${importPath(
+        list_path,
+        "src/back/routes/urls.ts"
+      )}";`,
+      post_header_html: `<a href={${create_action_name}URL}> Create </a>`,
+      render_item: (collection_name2) => `	async renderItem(ctx: Context, item: CollectionItem<typeof ${toPascalCase(
+        collection_name2
+      )}>) {
+					   return <tr>
+						   {displayFields.map(({ field, format }) => {
+							   // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-explicit-any
+							   const value = item.get(field as any);
+							   return <td>{format ? format(value, item) : value}</td>;
+						   })}
+                           <td><div class="sealious-list__actions">
+                               <a href={${edit_action_name}URL(item.id)}>Edit</a>
+                               <a data-turbo-method="POST" data-turbo-confirm="Delete item?" href={${delete_action_name}URL(item.id)}>Delete</a>
+                               </div>
+                           </td>
+					   </tr>;
+				   }`
+    }
   );
-  const list_content = `import { CRUD } from "@sealcode/crud-ui";
-import type { CollectionItem } from "sealious";
-import type { ListFilterRender } from "@sealcode/sealgen";
-import { Controls, DefaultListFilters, Fields } from "@sealcode/sealgen";
-import { ${toPascalCase(
-    collection_name
-  )} } from "src/back/collections/collections.js";
-import html from "src/back/html.js";
-
-export const actionName = "${toPascalCase(collection_name)}CRUD";
-
-const edit_fields = <const>
-{
-	${field_handler_results.filter(({ hide_field }) => !hide_field).map(({ field }) => field).filter((e) => e != "").join(",\n")}
-};
-
-
-const edit_controls = [
-	${field_handler_results.filter(({ hide_control }) => !hide_control).map(({ controls }) => controls).filter((e) => e != "").join(",\n")}
-]
-
-// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-const fields_for_display = [
-${makeDefaultDisplayFields(collection_fields)}
-] as {
-	field: keyof (typeof ${toPascalCase(collection_name)})["fields"];
-	label: string;
-	format?: (value: unknown, item: CollectionItem<typeof ${toPascalCase(
-    collection_name
-  )}>) => string | Promise<string>;
-}[];
-
-// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-const fields_for_filters = [
-     ${makeDefaultFilterFields(collection_fields)}
-] as {
-	field: keyof (typeof ${uppercase_collection})["fields"];
-	render?: ListFilterRender;
-	prepareValue?: (filter_value: unknown)=>unknown; // set this function to change what filter value is passed to Sealious
-}[];
-
-export default new CRUD({
-	collection: ${toPascalCase(collection_name)},
-	nice_collection_name: "${toPascalCase(collection_name)}",
-	fields_for_display,
-	fields_for_filters,
-	html,
-	list_title: "${toPascalCase(collection_name)} list",
-	edit_title: "Edit",
-	edit_button_text: "Edit",
-	delete_button_text: "Delete",
-	back_to_list_button_text: "\u2190 Back to ${toPascalCase(collection_name)} list",
-	edit_fields,
-	edit_controls,
-	form_value_to_sealious_value: {},
-	sealious_value_to_form_value: {},
-	post_edit: async () => {},
-	post_create: async () => {},
-});
-`;
-  await writeFile(list_path, await formatWithPrettier(list_content));
+  await writeFile(list_path, list_content);
+  const fields_path = target_locreq.resolve(
+    `src/back/routes/${escape_url_params(url)}/shared.ts`
+  );
+  const fields_content = await sharedCrudFormFields(
+    collection_name,
+    fields_path
+  );
+  await writeFile(fields_path, fields_content);
+  const create_path = target_locreq.resolve(
+    `src/back/routes/${escape_url_params(url)}/create.form.ts`
+  );
+  const create_content = await createItemFormTemplate(
+    create_action_name,
+    create_path,
+    collection_name,
+    list_action_name
+  );
+  await writeFile(create_path, create_content);
+  const edit_path = target_locreq.resolve(
+    `src/back/routes/${escape_url_params(url)}/[id]/edit.form.ts`
+  );
+  const edit_content = await editItemFormTemplate(
+    edit_action_name,
+    edit_path,
+    collection_name,
+    list_action_name
+  );
+  await writeFile(edit_path, edit_content);
+  const delete_path = target_locreq.resolve(
+    `src/back/routes/${escape_url_params(url)}/[id]/delete.page.tsx`
+  );
+  const base_import_path = curryImportPath(delete_path);
+  const delete_content = await itemDeleteTemplate(
+    delete_action_name,
+    collection_name,
+    list_action_name,
+    base_import_path
+  );
+  await writeFile(delete_path, delete_content);
   await generateRoutes();
 }
 export {

package/lib/add-list-route.test.js

@@ -2,7 +2,7 @@ import { getBrowser } from "./utils/browser-creator.js";
 import { RealAppTest } from "./test_utils/test-on-real-app.js";
 import { collectionTemplate } from "./templates/collection.js";
 import assert from "node:assert";
-describe("single-reference.test", () => {
+describe("single-reference", () => {
   let page;
   before(async () => {
     const browser = await getBrowser();

package/lib/add-route.js

@@ -2,7 +2,6 @@ import { existsSync, promises as fs } from "fs";
 import _locreq from "locreq";
 import { resolve } from "path";
 import { generateRoutes } from "./generate-routes.js";
-import { testTemplate } from "./templates/route-test.js";
 import { escape_url_params } from "./utils/escape-url-params.js";
 import prompts from "prompts";
 import { Templates } from "./templates/templates.js";
@@ -67,12 +66,6 @@ async function addRoute(params, app_directory = process.cwd()) {
   }
   await fs.mkdir(resolve(file_path, "../"), { recursive: true });
   await fs.writeFile(file_path, await template(action, file_path));
-  if (mode !== "lpr" && mode !== "jdd-editor") {
-    await fs.writeFile(
-      test_file_path,
-      await testTemplate(action, file_path)
-    );
-  }
   console.log(`${file_path} created`);
   console.log(`${test_file_path} created`);
   await generateRoutes();

package/lib/build.js

@@ -86,7 +86,9 @@ async function build(watch) {
   ];
   await Promise.all(builders.map((b) => b.build()));
   if (watch) {
-    const watcher = chokidar.watch("src", { ignoreInitial: true });
+    const watcher = chokidar.watch(["src", ...controller_dirs], {
+      ignoreInitial: true
+    });
     const port = await get_notifier_port();
     const notifier = make_notifier(port, 8080);
     await write_notifier_config(watch, port);

package/lib/cli.js

@@ -1,17 +1,15 @@
 #!/usr/bin/env node
 import yargs from "yargs/yargs";
 import { addCollection } from "./add-collection.js";
-import { addCRUD } from "./add-crud.js";
 import { addJDDComponent } from "./add-jdd-component.js";
 import { addRoute } from "./add-route.js";
-import { addVerboseCRUD } from "./add-verbose-crud.js";
+import { addCRUD } from "./add-crud.js";
 import { buildProject } from "./build.js";
 import { generateCollections } from "./generate-collections.js";
 import { generateComponents } from "./generate-components.js";
 import { generateRoutes } from "./generate-routes.js";
 import { getFonts } from "./get-fonts.js";
 import { makeEnv } from "./make-env.js";
-import { crudFieldSnippets } from "./crud-field-snippets.js";
 import {
   registerExternalControllers,
   registerExternalStyles
@@ -19,7 +17,6 @@ import {
 const actions = {
   "add-collection": addCollection,
   "add-route": addRoute,
-  "add-verbose-crud": addVerboseCRUD,
   "add-crud": addCRUD,
   "generate-collections": generateCollections,
   "generate-components": generateComponents,
@@ -34,7 +31,7 @@ const actions = {
   "make-env": makeEnv,
   "add-component": addJDDComponent,
   "get-fonts": getFonts,
-  "crud-field-snippets": crudFieldSnippets,
+  // "crud-field-snippets": crudFieldSnippets,
   "register-external-controllers": registerExternalControllers,
   "register-external-styles": registerExternalStyles
 };

package/lib/controllers/table-add-button.stimulus.js

@@ -0,0 +1,35 @@
+import { Controller } from "stimulus";
+class table_add_button_stimulus_default extends Controller {
+  constructor() {
+    super(...arguments);
+    this.defaultRowsNumber = 20;
+  }
+  static {
+    this.targets = ["textarea"];
+  }
+  addRow() {
+    const template = this.element.closest("turbo-frame")?.querySelector("template");
+    if (!template) {
+      throw new Error("Couldn't find template");
+    }
+    const tbody = this.element.closest("turbo-frame")?.querySelector("tbody");
+    if (!tbody) {
+      throw new Error("tbody not found");
+    }
+    const orig_template = template.innerHTML;
+    const placeholder = this.element.getAttribute("data-table-placeholder");
+    if (!placeholder) {
+      throw new Error("Could find placeholder attribute");
+    }
+    template.innerHTML = orig_template.replaceAll(
+      placeholder,
+      String(tbody.querySelectorAll("tr").length)
+    );
+    tbody.appendChild(template.cloneNode(true).content);
+    template.innerHTML = orig_template;
+  }
+}
+export {
+  table_add_button_stimulus_default as default
+};
+//# sourceMappingURL=table-add-button.stimulus.js.map