@foormjs/atscript 0.2.0

package/dist/plugin.mjs

@@ -0,0 +1,299 @@
+import { AnnotationSpec } from '@atscript/core';
+
+/**
+ * Attempts to compile a function string with `new Function` and returns
+ * diagnostic errors if it fails. Used by @foorm.fn.* and @foorm.validate
+ * annotation validate hooks.
+ */
+function validateFnString(fnStr, range) {
+    try {
+        // eslint-disable-next-line no-new-func
+        new Function('v', 'data', 'context', 'entry', `return (${fnStr})(v, data, context, entry)`);
+    }
+    catch (error) {
+        return [
+            {
+                severity: 1,
+                message: `Invalid function string: ${error.message}`,
+                range,
+            },
+        ];
+    }
+    return undefined;
+}
+function fnAnnotation(description) {
+    return new AnnotationSpec({
+        description,
+        nodeType: ['prop'],
+        argument: {
+            name: 'fn',
+            type: 'string',
+            description: 'JS function string: (value, data, context, entry) => result',
+        },
+        validate(token, args) {
+            if (args[0]) {
+                return validateFnString(args[0].text, args[0].range);
+            }
+            return undefined;
+        },
+    });
+}
+function fnTopAnnotation(description) {
+    return new AnnotationSpec({
+        description,
+        nodeType: ['interface'],
+        argument: {
+            name: 'fn',
+            type: 'string',
+            description: 'JS function string: (data, context) => result',
+        },
+        validate(token, args) {
+            if (args[0]) {
+                return validateFnString(args[0].text, args[0].range);
+            }
+            return undefined;
+        },
+    });
+}
+const annotations = {
+    foorm: {
+        // ── Form-level static annotations ────────────────────────
+        title: new AnnotationSpec({
+            description: 'Static form title',
+            nodeType: ['interface'],
+            argument: {
+                name: 'title',
+                type: 'string',
+                description: 'The form title text',
+            },
+        }),
+        submit: {
+            text: new AnnotationSpec({
+                description: 'Static submit button text',
+                nodeType: ['interface'],
+                argument: {
+                    name: 'text',
+                    type: 'string',
+                    description: 'Submit button label',
+                },
+            }),
+        },
+        // ── Field-level static annotations ───────────────────────
+        type: new AnnotationSpec({
+            description: 'Field input type',
+            nodeType: ['prop'],
+            argument: {
+                name: 'type',
+                type: 'string',
+                values: [
+                    'text',
+                    'password',
+                    'number',
+                    'select',
+                    'textarea',
+                    'checkbox',
+                    'radio',
+                    'date',
+                    'paragraph',
+                    'action',
+                ],
+                description: 'The input type for this field',
+            },
+        }),
+        component: new AnnotationSpec({
+            description: 'Named component override for rendering this field',
+            nodeType: ['prop'],
+            argument: {
+                name: 'name',
+                type: 'string',
+                description: 'Component name from the components registry',
+            },
+        }),
+        autocomplete: new AnnotationSpec({
+            description: 'HTML autocomplete attribute value',
+            nodeType: ['prop'],
+            argument: {
+                name: 'value',
+                type: 'string',
+                description: 'Autocomplete value (e.g., "email", "given-name")',
+            },
+        }),
+        altAction: new AnnotationSpec({
+            description: 'Alternate submit action name for this field',
+            nodeType: ['prop'],
+            argument: {
+                name: 'action',
+                type: 'string',
+                description: 'The action name emitted on submit',
+            },
+        }),
+        value: new AnnotationSpec({
+            description: 'Default value for this field',
+            nodeType: ['prop'],
+            argument: {
+                name: 'value',
+                type: 'string',
+                description: 'Default value (parsed by field type at runtime)',
+            },
+        }),
+        order: new AnnotationSpec({
+            description: 'Explicit rendering order for this field',
+            nodeType: ['prop'],
+            argument: {
+                name: 'order',
+                type: 'number',
+                description: 'Numeric order (lower = earlier)',
+            },
+        }),
+        hidden: new AnnotationSpec({
+            description: 'Statically mark this field as hidden',
+            nodeType: ['prop'],
+        }),
+        disabled: new AnnotationSpec({
+            description: 'Statically mark this field as disabled',
+            nodeType: ['prop'],
+        }),
+        // ── Options annotation ──────────────────────────────────
+        options: new AnnotationSpec({
+            description: 'Static option for select/radio fields. Repeat for each option. Label is the display text, value is the key (defaults to label).',
+            nodeType: ['prop'],
+            multiple: true,
+            mergeStrategy: 'replace',
+            argument: [
+                {
+                    name: 'label',
+                    type: 'string',
+                    description: 'Display label for the option',
+                },
+                {
+                    name: 'value',
+                    type: 'string',
+                    optional: true,
+                    description: 'Value/key for the option (defaults to label if omitted)',
+                },
+            ],
+        }),
+        // ── Validation annotation ────────────────────────────────
+        validate: new AnnotationSpec({
+            description: 'Custom JS validator function string. Returns true for pass, or an error message string.',
+            nodeType: ['prop'],
+            multiple: true,
+            mergeStrategy: 'append',
+            argument: {
+                name: 'fn',
+                type: 'string',
+                description: 'JS function string: (value, data, context) => boolean | string',
+            },
+            validate(token, args) {
+                if (args[0]) {
+                    return validateFnString(args[0].text, args[0].range);
+                }
+                return undefined;
+            },
+        }),
+        // ── Computed (fn) annotations ────────────────────────────
+        fn: {
+            // Form-level computed
+            title: fnTopAnnotation('Computed form title: (data, context) => string'),
+            submit: {
+                text: fnTopAnnotation('Computed submit button text: (data, context) => string'),
+                disabled: fnTopAnnotation('Computed submit disabled state: (data, context) => boolean'),
+            },
+            // Field-level computed
+            label: fnAnnotation('Computed label: (value, data, context, entry) => string'),
+            description: fnAnnotation('Computed description: (value, data, context, entry) => string'),
+            hint: fnAnnotation('Computed hint: (value, data, context, entry) => string'),
+            placeholder: fnAnnotation('Computed placeholder: (value, data, context, entry) => string'),
+            disabled: fnAnnotation('Computed disabled state: (value, data, context, entry) => boolean'),
+            hidden: fnAnnotation('Computed hidden state: (value, data, context, entry) => boolean'),
+            optional: fnAnnotation('Computed optional state: (value, data, context, entry) => boolean'),
+            classes: fnAnnotation('Computed CSS classes: (value, data, context, entry) => string | Record<string, boolean>'),
+            styles: fnAnnotation('Computed inline styles: (value, data, context, entry) => string | Record<string, string>'),
+            options: fnAnnotation('Computed select/radio options: (value, data, context, entry) => Array'),
+        },
+    },
+};
+
+const primitives = {
+    foorm: {
+        type: 'phantom',
+        isContainer: true,
+        documentation: 'Non-data UI elements for form rendering',
+        extensions: {
+            action: {
+                documentation: 'Form action button — not a data field, excluded from form data. Use with @foorm.altAction to define alternate submit actions.',
+            },
+            paragraph: {
+                documentation: 'Read-only paragraph text — rendered as static content, not an input field. Use @meta.label for the paragraph text.',
+            },
+            select: {
+                type: 'string',
+                documentation: 'Dropdown select field. Use @foorm.options to define static choices or @foorm.fn.options for computed choices.',
+            },
+            radio: {
+                type: 'string',
+                documentation: 'Radio button group. Use @foorm.options to define static choices or @foorm.fn.options for computed choices.',
+            },
+            checkbox: {
+                type: 'boolean',
+                documentation: 'Single boolean checkbox toggle.',
+            },
+        },
+    },
+};
+
+const BUILTIN_TYPES = [
+    'text',
+    'password',
+    'number',
+    'select',
+    'textarea',
+    'checkbox',
+    'radio',
+    'date',
+    'paragraph',
+    'action',
+];
+function foormPlugin(opts) {
+    return {
+        name: 'foorm',
+        config() {
+            var _a, _b, _c, _d;
+            if (!((_a = opts === null || opts === void 0 ? void 0 : opts.extraTypes) === null || _a === void 0 ? void 0 : _a.length) && !((_b = opts === null || opts === void 0 ? void 0 : opts.components) === null || _b === void 0 ? void 0 : _b.length)) {
+                return { primitives, annotations };
+            }
+            const foormNs = annotations.foorm;
+            const overrides = {};
+            if ((_c = opts.extraTypes) === null || _c === void 0 ? void 0 : _c.length) {
+                overrides.type = new AnnotationSpec({
+                    description: 'Field input type',
+                    nodeType: ['prop'],
+                    argument: {
+                        name: 'type',
+                        type: 'string',
+                        values: [...BUILTIN_TYPES, ...opts.extraTypes],
+                        description: 'The input type for this field',
+                    },
+                });
+            }
+            if ((_d = opts.components) === null || _d === void 0 ? void 0 : _d.length) {
+                overrides.component = new AnnotationSpec({
+                    description: 'Named component override for rendering this field',
+                    nodeType: ['prop'],
+                    argument: {
+                        name: 'name',
+                        type: 'string',
+                        values: opts.components,
+                        description: 'Component name from the components registry',
+                    },
+                });
+            }
+            return {
+                primitives,
+                annotations: Object.assign(Object.assign({}, annotations), { foorm: Object.assign(Object.assign({}, foormNs), overrides) }),
+            };
+        },
+    };
+}
+
+export { annotations, foormPlugin, primitives };

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@foormjs/atscript",
+  "version": "0.2.0",
+  "description": "ATScript plugin for foormjs — form annotations, primitives, and validation",
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./plugin": {
+      "types": "./dist/plugin.d.ts",
+      "import": "./dist/plugin.mjs",
+      "require": "./dist/plugin.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "typesVersions": {
+    "*": {
+      "plugin": [
+        "dist/plugin.d.ts"
+      ],
+      "": [
+        "dist/index.d.ts"
+      ]
+    }
+  },
+  "build": [
+    {},
+    {
+      "entries": [
+        "src/plugin.ts"
+      ],
+      "dts": true
+    }
+  ],
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/foormjs/foormjs.git",
+    "directory": "packages/atscript"
+  },
+  "keywords": [
+    "foorm",
+    "foormjs",
+    "forms",
+    "validations",
+    "atscript"
+  ],
+  "author": "Artem Maltsev",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/foormjs/foormjs/issues"
+  },
+  "homepage": "https://github.com/foormjs/foormjs/tree/main/packages/atscript#readme",
+  "dependencies": {
+    "@atscript/core": "^0.1.6",
+    "@prostojs/deserialize-fn": "^0.0.5",
+    "foorm": "^0.2.0"
+  },
+  "peerDependencies": {
+    "@atscript/typescript": "^0.1.6"
+  },
+  "scripts": {
+    "pub": "pnpm publish --access public --no-git-checks"
+  }
+}