מדריך ה-LLM של Studio
מודל המסמך של תוכנית, מדריך מאפייני xu-*, וכללי תהליך העבודה שסוכן AI לומד לפני הקריאה הראשונה שלו לכלי.
כל פרויקט ב-Studio, וכל טבלה, מסך, סקריפט ונתיב בתוכו, הוא מסמך JSON אחד של CouchDB שנקרא תוכנית (docType: "studio"). הדף הזה הוא אותו מדריך שסוכן AI מקבל כשהוא בונה אחת, שנכתב מחדש כתיעוד: מבנה המסמך הזה, המאפיינים שמניעים את הממשק שלו, הפעולות שתהליך עבודה יכול לבצע, והטעויות שמופיעות בבנייה אמיתית.
איך סוכן AI מקבל את המדריך הזה
מחברים לקוח MCP אל Xuda, והתשובה הראשונה, קריאת initialize, נושאת את המדריך הזה כ-instructions של הסשן, ממוזג טרי מהכללים החיים של הפלטפורמה עצמה כך שהוא לעולם לא יתאר משהו שהבודק שנפרס כבר לא אוכף. ראו חיבור לקוח AI דרך MCP.
מתוך סשן, שתי שיטות מגיעות ישירות לאותו חומר, דרך MCP או REST רגיל, ולא דורשות דבר מעבר למפתח API רגיל:
הסדר שנקבע: קוראים את הנושא שמתאים למה שבונים, מביאים דוגמה מתאימה, יוצרים את התוכנית דרך המפעל (create_prog), בונים בתוך אזורי התוכן שלה, מאמתים (validate_prog) ומתקנים כל מה שהיא מדווחת עליו, שומרים (save_prog), ואז מביאים מחדש כדי לוודא. שמירה שמחזירה -409 אומרת שהמסמך השתנה מאז שנקרא: מביאים מחדש, מחילים שוב, מנסים שוב.
מודל המסמך של תוכנית
המעטפת
קוד השרת והמפעל הוא הבעלים של השדות האלה; בנייה שנכתבת עורכת רק את אזורי התוכן שמתחתיהם.
_idעוקב אחרי<last 3 chars of app_id>_<3-letter type abbreviation>_<12 hex>, למשל392_cmp_...לרכיב,392_tbl_...לטבלה,392_jvs_...לתוכנית javascript,392_gtd_.../392_std_...ל-get_data / set_data,392_fld_...לתיקייה. המפעל מייצר מזהים, בנייה אף פעם לא ממציאה אחד.statהוא 3 לפעיל, 4 למחוק רך (מה שמחיקת תוכנית קובעת). העץ של Studio מציג רקstat: 3.properties.menuTypeהוא אחד מ-globals,table,get_data,set_data,batch,alert,javascript,folder,route,api,component,ai_agent.studio_meta.parentIdממקם את הצומת בעץ של Studio: או מזהה של תוכנית אחרת (בדרך כלל תיקייה) או אחד משורשי הסוגים,programs(לוגיקה ורכיבים),database(טבלאות),routes,globals,ai_agents.parentIdשלא מזוהה משאיר את הצומת בלתי נראה בעץ והוא שגיאת בודק.
אזורי תוכן לפי menuType
מסמך ה-globals
לכל פרויקט יש בדיוק מסמך אחד global_<app_id> (menuType: "globals"). ה-progFields שלו קריאים מכל תוכנית אחרת כ-@field_id. שני גלובליים של המערכת נשלחים בכל פרויקט: @SYS_GLOBAL_OBJ_LOGIN_USER_INFO למשתמש המחובר, ו-@SYS_GLOBAL_OBJ_REFS לאלמנטים שנרשמו עם xu-ref. אי אפשר למחוק לא את מסמך ה-globals ולא את שורש העץ.
חובות מבניות
properties,properties.menuType,properties.menuName,studio_metaו-studio_meta.parentIdהם חובה בכל מסמך.- רשומת
progFieldsצריכהidייחודי,data.field_id,data.typeמסוגvirtual,table,expressionאוdatasource, ו-props.fieldTypeמסוגstring,number,boolean,arrayאוobject. - שמות משתנים שמורים של סביבת הריצה,
_NULL,_THIS,_FOR_KEY,_FOR_VAL,_ROWNO,_ROWID,_ROWDOC,_KEY,_VAL, אף פעם לא מוגדרים מחדש כמזהי שדות. - מזהים כפולים,
menuTypeלא מוכרים ואזורים פגומים הם כולם שגיאות קשות ש-validate_progמדווחת עליהן ישירות.
ביטויים ומאפייני xu-*
תחביר ביטויים
ביטויים רצים מול מערך הנתונים של התוכנית עצמה. כל שדה, מקומי, קשור לטבלה, גלובלי או פרמטר, מופנה עם @: @search_v, @ORD_Total, @SYS_GLOBAL_OBJ_LOGIN_USER_INFO, JavaScript רגיל סביבו, @count_v > 0 ? 'has rows' : 'empty'. ליטרל אובייקט צריך סוגריים עוטפים, ({ ORD_Status: @status_v }). בתוך לולאת xu-for, הפריט הנוכחי הוא @_FOR_VAL והמפתח או האינדקס שלו @_FOR_KEY (ניתנים לשינוי שם עם xu-for-key / xu-for-val). xu-render ותנאים אחרים מחזירים ישירות את הערך האמיתי או השקרי, אף פעם לא מחרוזת "Y" / "N" או השוואה נוספת.
בכל מקום אחר מפנים לשדה עם @. xu-bind מקבל במקום זה את מזהה השדה החשוף: xu-bind="search_v", אף פעם לא xu-bind="@search_v".
מאפייני xu
משפחות קידומות
משפחות מאפיינים שמקבלות סיומת. ערכי xu-on הם תמיד מערכים של אובייקטי מטפל; ערכי xu-exp הם תמיד מחרוזות ביטוי.
הערך של מאפיין xu-on:* הוא תמיד מערך של אובייקטי מטפל, וכל workflow הוא מערך של שלבי פעולה (מדריך הפעולות המלא להלן, תחת תוכניות לוגיקה ותהליכי עבודה). props.condition של שלב מגביל אותו; props.async: true מפעיל אותו בלי להמתין.
סמנטיקה קריטית
xu-exp:classמחליף את מאפיין ה-classהסטטי ולא מוסיף אליו. באלמנט שנושא את שניהם, הסטטי מתעלמים ממנו, ולכן מחלקות הפריסה שייכות גם בתוך הביטוי:xu-exp:class="'card p-4 ' + (@active_v ? 'ring' : '')".xu-scriptמקבל ביטוי חשוףfunction (el) { ... }, שמוערך עםevalונקרא עם אלמנט ה-DOM ברגע שהצומת נעשה גלוי. מגנים מפני הרצות חוזרות (if (el.__bound) return; el.__bound = true;) ומגבילים כל שאילתה ל-el, אף פעם לא ל-document.xu-styleמוגבל היקף אוטומטית: כל סלקטור מקבל קידומת של[xu-ui-id]של הצומת, ולכן סלקטורי אלמנט ומחלקה רגילים נשארים מקומיים ולא דולפים.- אף אחד מהערכים של
xu-scriptאוxu-styleלא יכול להכיל תו מרכאות ('או"), קנבס המעצב מסדר מאפיינים בלי הגנה ומרכאה אחת משחיתה את הרכיב. הקטע על תוכניות JavaScript להלן מכסה טכניקות בלי מרכאות. - טקסט סטטי שייך למאפיין
contentשל אלמנט.xu-exp:xu-contentהוא לטקסט דינמי בלבד.
תגים
תגי כתיבה מלבד HTML רגיל: xu-template, xu-single-view, xu-multi-view, xu-panel, xu-teleport, xu-slot.
xu-single-viewמגביל רשומה אחת (שורש של טופס, שאפשר להשתמש בו גם מקונן).xu-multi-viewחוזר על הילדים שלו פעם לכל שורה בנתונים הקשורים.xu-panelמטמיע תוכנית אחרת (מאפייןprogramועוד קלטיxu-exp:<param>). רק מאפייני HTML סטנדרטיים (class,id,style,title,hidden,slot,name,role,tabindex) שייכים עליו מלבד ביטויי הפרמטרים.xu-teleportמציג את הילדים שלו ביעד DOM אחר (toאוxu-exp:to).- שם תג באות גדולה (
Button,Card) הוא רכיב מקומפל, לא אלמנט HTML, ראו הטמעה להלן.
רכיבים
רכיב (menuType: "component") הוא יחידת ממשק: עץ אלמנטים (progUi) שקשור למצב מקומי (progFields), נתונים אופציונליים (progDataSource), לוגיקת מחזור חיים (progEvents) וממשק קלט/פלט (properties.progParams).
מאפיינים
renderTypeהואformלרשומה אחת (אלמנט שורשxu-single-view) אוgrid/listלאחד שחוזר לכל שורת נתונים (אלמנט שורשxu-multi-view).rwModeהואRלקריאה אוUלעדכון;allowCreateאומר אם אפשר להכניס שורה חדשה כשאף אחת לא מתאימה.- מוסכמת השמות של
progParams: פרמטרים מסתיימים ב-_in/_out, שדות וירטואליים מקומיים לרכיב מסתיימים ב-_v. uiFrameworkמשקף את מה שהרכיבים הקיימים של הפרויקט כבר משתמשים בו. פרויקט קיים שמשמיט אותו צריך להמשיך להשמיט אותו, הגדרת תוסף מסגרת שה-drive של הפרויקט לא מגיש בפועל תוקעת את התצוגה המקדימה החיה על מסך ריק.
עץ האלמנטים (progUi)
צומת ה-root של המפעל נשאר; בנייה עובדת בתוך ה-children שלו. כל צומת צריך מזהה ייחודי (צמתים חדשים משתמשים ב-ui-<uuid>), type: "element" ו-tagName, בלי סוגי צמתים comment או text, טקסט סטטי נמצא ב-content במקום. כל צומת צריך attributes: {} ו-children: [] גם כשהם ריקים, מסדר הקנבס של המעצב ניגש לשניהם בכל צומת והשמטה שוברת את התצוגה המקדימה של הרכיב עצמו.
הטמעה: xu-panel או רכיב מקומפל
שניהם נטענים בשקיפות, בלי אלמנט עוטף, ושניהם נקבעים על ידי אות אחד: אם tagName מתחיל באות גדולה.
xu-panel,tagNameבאותיות קטנות ועוד מאפייןprogram, מטמיע תוכנית אחרת, ילד שקשור לבסיס נתונים או בעל מצב עם שדות ואירועים משלו.programהוא המזהה של הילד (אוxu-exp:progלדינמי), ערכים מגיעים לפרמטרי ה-_inשלו דרךxu-exp:<param>.- תג באות גדולה ועוד מאפיין
libraryטוען רכיב מקומפל, רכיב בסיס של מערכת עיצוב או חלק שהאפליקציה עצמה קימפלה. כל מאפיין רגיל הופך ל-prop (props.<name>), אף פעם לא למאפיין DOM, כי הרכיב לא מציג אלמנט משלו. לצומת רכיב אין פרמטרי out, בניגוד ל-xu-panelשום דבר לא כותב ערך חזרה לשדות שלכם.
<Buton> עם שגיאת כתיב עדיין נתבע כתג רכיב, אף פעם לא חוזר לאלמנט HTML לא מוכר, וזורק שגיאה בטעינה שנוקבת בתג, בספרייה ובכל מקור שנוסה. validate_prog לא בודקת היום תגי רכיב או ערכי library, התצוגה המקדימה החיה היא הבדיקה היחידה.
progFields
data.type הוא virtual למצב מקומי, table לעמודה של מקור הנתונים הקשור, או expression / datasource. ה-workflow של שדה רץ בשינוי. ברירת מחדל קובעת props.fieldValue; שדה מחושב קובע props.fieldComputed: true ועוד propExpressions.fieldValue.
progDataSource
רשומה אחת לפי מפתח (טופס): dataSourceFilterModelType: "index" עם dataSourceIndexId שקיים ב-tableIndexes של הטבלה עצמה. רשימה מסוננת (grid או list): dataSourceFilterModelType: "query" עם filterModelMongoFx, מחרוזת ביטוי בסגנון Mongo. dataSourceType הוא table, array, json, csv, none, או ריק לרכיב הצגה טהור בלי מקור נתונים בכלל.
progEvents ושלושת הוקי מחזור החיים
סוגי אירועים: on_load, on_exit, before_record, after_record, record_not_found, locate_not_found, screen_ready, on_refresh, on_unload, client_interval, user_defined. אירועי user_defined מופעלים מכל מקום עם הפעולה raise_event; screen_ready הוא הוו הרגיל לטעינה.
שלושת הוקים מובנים של רכיב מחלקים את העבודה, שימוש בלא הנכון הוא מקור נפוץ לבאגים:
screen_ready
מופעל פעם אחת לכל מופע. יוצרים כאן DOM וווידג'טים.
on_refresh
מופעל אחרי כל טעינה, כולל הראשונה, מיד אחרי screen_ready. מוסרים כאן נתונים חדשים לווידג'טים שכבר קיימים. הכנסת עבודת רענון ל-screen_ready במקום זה מריצה מחדש קוד יצירה מול DOM שעדיין קיים ומערימה ווידג'ט שני.
on_unload
מופעל כשהמופע מפורק. הורסים מה שהתוכנית יצרה, ווידג'טים, טיימרים, מאזיני document / window, משקיפים. המנוע יכול לשחרר רק מה שהוא יצר, מאזין שנקשר ל-document שורד את הפאנל אחרת.
דפוסים
- מצבי טעינה וריקים: שמים
xu-ref="myref"על האלמנט הקשור לנתונים, ואז מגבילים אלמנטי שלד או ריקים עםxu-renderמעל(@SYS_GLOBAL_OBJ_REFS).myref, מערך הנתונים שלו מתחבר כשהנתונים מגיעים. - חלונות מודאליים: בונים את הדיאלוג כרכיב משלו, פותחים אותו עם הפעולה
call_modal. - שמירה או מחיקה של שורה קשורה:
invoke_actionעםact_save/act_delete, או תוכניתset_dataייעודית לכל מה שמעבר לשורה הנוכחית.
תוכניות לוגיקה ותהליכי עבודה
סוגי תוכניות לוגיקה חולקים את מנגנון הנתונים של רכיב (progDataSource, progFields, progEvents, properties.progParams) בלי שום ממשק:
פרמטרים
קורא מעביר ערכים דרך name.parameters של הפעולה, { "order_id_in": { "value": "", "fx": "@selected_id_v" } }, value לערך סטטי, fx לביטוי. הבודק מוודא שתוכנית היעד קיימת ושה-menuType שלה מתאים לפעולה.
פעולות תהליך עבודה
תהליך עבודה הוא מערך של שלבים, { "id": "...", "data": { "action": "...", "name": { ... }, "enabled": true }, "props": {} }, שרצים לפי הסדר. props.condition מגביל שלב, props.async: true מפעיל אותו בלי להמתין. תהליכי עבודה מופיעים במטפלי xu-on:*, ב-progEvents[].workflow, וב-workflow של שדה עצמו.
invoke_action מקבלת act_next, act_prev, act_first, act_last, act_reload, act_refresh, act_print, act_save, act_delete (בהקשר של רכיב בלבד).
alter_ui_element, create_ui_element, info_ui_element, remove_ui_element, empty_ui_element, cache_ui_element, load_ui_element. מניעים את הממשק דרך שדות ו-xu-exp / xu-render במקום פעולת אלמנט הכרחית.
בורר הפעולות של Studio עצמו מציע קריאה לסוכן AI ו-קריאה לסוכן מיון לצד הפעולות שלמעלה. אף אחת מהן לא בטבלה הזו כי אף אחת מהן אינה פעולה: ל-validate_prog אין מקרה בשבילן והיא מדווחת invalid trigger type, ולמנוע תהליכי העבודה של סביבת הריצה אין מטפל בהן גם כן, ולכן שלב שמור לעולם לא רץ גם אם מתעלמים מהשגיאה. כדי שתוכנית אחת תגיע לסוכן שפורסם, מוסיפים כלי סוכן AI לרשימת הכלים של סוכן אחר (agentConfig.agent_tools של מסמך menuType: "ai_agent"), לא שלב תהליך עבודה ברכיב, ב-get_data או בכל סוג תוכנית אחר.
ה-name.value של update מקצה שדות עם זוגות @field: expression מופרדים בנקודה פסיק, או אובייקט JSON5, "@saving_v: true; @status_v: 'sent'". קריאה לתוכנית אחרת נוקבת בה תחת name.prog, ומתאימה את הפעולה לסוג של התוכנית עצמה (get_data צריכה תוכנית get_data, call_native_javascript תוכנית javascript, וכן הלאה).
call_library קוראת לשיטה של תוסף מותקן: name.plugin_name חייב להיות נרכש ומותקן באפליקציה או שהבודק דוחה את השלב, name.library_method אחת מהשיטות שהתוסף מייצא, name.library_props השדות המוצהרים שלה. שני שמות props הם מוסכמה בין תוספים ולא ספציפיים לאחד מהם: event_name_for_successful_callback מעלה את האירוע הזה עם התשובה של השיטה, field_id_to_return_result כותב את התשובה ישירות לשדה הזה, אף אחד מהם לא חובה.
סוגי progEvents
on_load, on_exit, before_record, after_record, record_not_found, locate_not_found, screen_ready, on_refresh, on_unload, client_interval, user_defined. screen_ready הוא ווי האתחול הרגיל; before_record / after_record / record_not_found / locate_not_found הם מחזור חיים של נתונים, במיוחד ל-set_data ול-batch; client_interval הוא טיימר שחוזר; user_defined מופעל מהפעולה raise_event.
טבלאות
תוכנית טבלה (menuType: "table") מגדירה טבלת בסיס נתונים: העמודות שלה (tableFields), האינדקסים שלה (tableIndexes), ותוסף בסיס הנתונים ששומר אותה (properties.databaseSocket). הורה בעץ: database, או תיקייה תחתיו.
databaseSocketחייב לנקוב בתוסף בסיס נתונים שמותקן בפרויקט,@xuda.io/xuda-dbs-plugin-xudaהוא ברירת המחדל של הפלטפורמה; טבלה קיימת באותו פרויקט היא ההפניה לאיזה socket להשתמש בו שוב.- נדרשים לפחות שדה אחד ולפחות אינדקס אחד.
field_idמתחיל באות, ואז אותיות, ספרות, קו תחתון, מקף, נקודתיים או נקודה, ונשאר ייחודי בתוך הטבלה.fieldTypeהואstring,number,boolean,array,objectאוdate;mandatory: trueהופך אותו לנדרש בשמירה.- כל אינדקס צריך
nameו-keysלא ריקים, וכל מפתח חייב להיותfield_idקיים.
מוסכמה: מוסיפים לעמודות קידומת של קוד טבלה בן שלוש אותיות, טבלה בשם "ORD - Orders" מקבלת ORD_Id, ORD_Total, ORD_Status. נותנים לכל טבלה שדה ייחודי <TBL>_Id עם אינדקס ייחודי עליו, קשירת רכיב לרשומה יחידה צריכה אותו.
משתמשים בטבלה בשלוש דרכים: progDataSource.dataSourceTableId של רכיב או שאילתה, תוכנית get_data / set_data / batch לגישה ברמת שורה מתהליכי עבודה, או xu.dbs_create / dbs_read / dbs_update / dbs_delete מסקריפט, שמכוסה בהמשך.
תוכניות JavaScript
תוכנית javascript (menuType: "javascript") מחזיקה מקור JS אמיתי ב-scriptData.value, שמקומפל בשמירה. save_prog מפעילה את הבנייה הזו ומחזירה את התוצאה כ-data.compile, { ok: true, dependencies } או { ok: false, error }. קומפילציה שנכשלה עדיין שומרת את המסמך, ולכן בנייה קוראת compile.ok ומתקנת לפני שממשיכים.
חוזה הביצוע
המקור נכתב כגוף async רגיל, בלי export, בלי עטיפה. בזמן ריצה הוא מתבצע כך:
params הם הקלטים של הקורא שכבר הוערכו; xu הוא ממשק סביבת הריצה להלן; ערך החזרה אופציונלי, הדרך הרגילה להחזיר תוצאות היא xu.set_field_value על שדות הרכיב הקורא. מרכאות מותרות כאן, בניגוד לערך של מאפיין xu-script.
ממשק xu של סביבת הריצה
שיטות dbs_* מקבלות את ה-_id של תוכנית הטבלה עצמה, אף פעם לא שם. Selector הם אובייקטים בסגנון Mongo על מזהי השדות, {} מחזיר הכול (ליימיט ברירת מחדל 999). ההקרנה של fields אופציונלית, [] מחזיר את כל השדות ורשימת מזהי שדות מחזירה רק אותם.
מעבירים נתונים פנימה: שדות, לא פרמטרים
call_native_javascript לא מעריכה עטיפות פרמטרים של {value, fx}, name.parameters מגיע לסקריפט גולמי. החוזה האמין: הרכיב שם קודם את המטען בשדה (שלב update או קלט xu-bind), תהליך העבודה קורא לתוכנית עם parameters: {} ריק, והסקריפט קורא אותו עם xu.get_field_value ומדווח חזרה עם xu.set_field_value. כשקוראים מסקריפט אחר במקום זה, xu.call_javascript(prog_id, {...}) כן מעבירה פרמטרים ישירות.
תכונות מוזרות של התצוגה המקדימה החיה
- כתיבות נתונים מגיעות לבסיס הנתונים האמיתי, אבל
xu.dbs_readקורא מאגר טיוטה מקומי שאולי לא מחזיק שורות טריות מהשרת, קריאה מיד אחרי כתיבה יכולה לחזור ריקה בתצוגה המקדימה למרות שהכתיבה נחתה (גלוי בלשונית נתונים של הטבלה ב-Studio). אפליקציות שנפרסו קוראות וכותבות לאותו מאגר. - סקריפטים מקומפלים נשמרים בקשיחות במטמון בתצוגות מקדימות של פיתוח, תצוגה מקדימה רצה יכולה להמשיך להריץ את הסקריפט הקודם גם אחרי טעינות מחדש אחרי ששמירה מקמפלת אותו מחדש. רענון קשיח של הדפדפן מנקה את זה.
xu.alertעם הצגהmodal,toastאוbrowserיכולה להופיע כ-alert()מקורי וחוסם בתצוגה המקדימה.xu.set_field_valueלשדה סטטוס היא הדרך הבטוחה יותר לדווח חזרה.
תוכנית javascript לעומת מאפיין xu-script
טכניקות בלי מרכאות ל-xu-script / xu-style
קנבס המעצב מסדר ערכי מאפיינים בלי הגנה, ולכן מרכאה אחת משחיתה את הסימון של הרכיב. תבניות מחרוזת נמנעות ממרכאות של מחרוזות לגמרי (el.textContent = `Ready`); התו " עצמו, למשל בזמן בניית CSV, מגיע מ-String.fromCharCode(34); סלקטורי מאפיין של CSS תקינים בלי מרכאות (el.querySelector(`[data-role=import-btn]`)); ושומר הרצה חוזרת, if (el.__bound) return; el.__bound = true;, מונע מסקריפט להיקשר פעמיים ברינדור מחדש.
מוקשים
כל רשומה להלן שברה בנייה אמיתית בשלב כלשהו. validate_prog תופסת את רובן, מריצים אותה לפני כל שמירה.
מכניקת ה-API
- כל תשובה היא
{ code, data },code < 0הוא שגיאה. create_progמחזירה את המסמך החדש תחתdata.prog, שמירה של כל התשובה במקום זה מתמידה מסמך פגום עםpropertiesקבור תחתprog.save_progמחליפה את המסמך כולו. מתחילים מהמסמך הנוכחי, אף פעם לא משלד שהורכב ביד;-409אומר שהוא השתנה מאז הקריאה האחרונה, מביאים מחדש, מחילים שוב, מנסים שוב.- דרך MCP,
prog_jsonו-properties_jsonמועברים כמחרוזות, שכבת סכמת הכלי מסירה מפתחות לא מוכרים מפרמטר אובייקט ויכולה להשמיט בשקט אזורים שלמים. delete_progהיא מחיקה רכה, היא קובעתstat: 4. אי אפשר למחוק את הצומתglobal_<app_id>.
תוכן המסמך
- אין
'או"בתוך ערכיxu-scriptאוxu-style. - מפתחות עם קידומת
$($folded,$childrenClass,$nodeBackClass), וגםpath,code,editCode, הם מצב תצוגה של המעצב ואף פעם לא שייכים לצומתprogUiשמור. - אין סוגי צמתים
commentאוtext, אלמנטים בלבד, טקסט סטטי ב-content. - כל צומת אלמנט צריך
attributes: {}ו-children: []גם כשהם ריקים. xu-exp:classמחליף אתclassהסטטי, כל מחלקה נחוצה שייכת בתוך הביטוי.xu-bindהוא מזהה שדה חשוף, בלי@, בכל מקום אחר שדות משתמשים ב-@.- רק מאפייני
xu-*המתועדים עושים משהו, מאפיין שהומצא מתעלמים ממנו בשקט ו-validate_progמזהירה. - השורש בעץ של תוכנית
ai_agentהואai_agents, שומרים אותה עםstudio_meta.parentId: "ai_agents"(או מזהה תיקייה תחתיו) אם הבודק מסמן אתparentId.
סביבת ריצה והצגה
tagNameבאות גדולה תמיד נתבע כרכיב, גם שגיאת כתיב, וזורק שגיאה בטעינה שנוקבת בתג, ב-libraryובכל מקור שנוסה, אין "לא מוצג" שקט כמו ל-xu-panelבלי תוכנית שנבחרה.validate_progלא בודקת תגי רכיב או ערכיlibrary, רק התצוגה המקדימה החיה תופסת כתיב שגוי.- אין CSS שירות (Tailwind או אחר) בזמן ריצה אלא אם תוסף
uiFrameworkשל הפרויקט באמת מספק אותו, מחלקות כמוp-4לא עושות כלום בשקט אחרת. עיצוב עצמאי הואxu-style, מוגבל היקף אוטומטית על ידי[xu-ui-id]. xu-scriptרץ פעם לכל נראות של אלמנט ויכול לפעול שוב ברינדור מחדש, מגנים עםel.__boundומגבילים שאילתות ל-el.
נתונים וסקריפטים
- פרמטרים של
call_native_javascriptלא מוערכים, מעבירים נתונים דרך שדות במקום זה (ראו מעבירים נתונים פנימה, למעלה). - שורות
dbs_readהן{id, value}, השדות נמצאים תחת.value, מזהה השורה ב-.id. לא מעבירים הקרנתfields, היא שוברת את הקריאה בצד השרת. - בתוך
xu-for, עוטפים את האיטרטור בסוגריים,(@_FOR_VAL).CNT_Nameמוערך,@_FOR_VAL.CNT_Nameנכשל בשקט ומציג במקומו את טקסט המקור שהוחלף. - כתיבות בתצוגה מקדימה נוחתות בבסיס הנתונים האמיתי; קריאות בתצוגה מקדימה מגיעות ממאגר טיוטה מקומי שיכול להיראות ריק מיד אחרי כתיבה.
- מעדיפים שדה סטטוס על פני ההצגה modal או toast של
xu.alertבתצוגות מקדימות, היא יכולה להופיע כ-alert()מקורי וחוסם.
מוודאים את העבודה
מביאים מחדש עם get_prog אחרי השמירה ומשווים למה שציפינו. לעבודת ממשק, פותחים את הרכיב ב-Studio ולוחצים על כפתור ההפעלה של התצוגה המקדימה, או על כתובת התצוגה המקדימה החיה של הפרויקט כשהיא זמינה. לתוכנית javascript, בודקים את data.compile.ok בכל שמירה. מתקנים כל שגיאה של validate_prog; מתייחסים לאזהרות שלה, מרכאות, מפתחות $, מאפיינים לא מוכרים, כפריטים לתיקון מיידי ולא כרעש.