77b4d10af8
Standardize settings file naming and relocate documentation files Fix code quality violations from rsx:check Reorganize user_management directory into logical subdirectories Move Quill Bundle to core and align with Tom Select pattern Simplify Site Settings page to focus on core site information Complete Phase 5: Multi-tenant authentication with login flow and site selection Add route query parameter rule and synchronize filename validation logic Fix critical bug in UpdateNpmCommand causing missing JavaScript stubs Implement filename convention rule and resolve VS Code auto-rename conflict Implement js-sanitizer RPC server to eliminate 900+ Node.js process spawns Implement RPC server architecture for JavaScript parsing WIP: Add RPC server infrastructure for JS parsing (partial implementation) Update jqhtml terminology from destroy to stop, fix datagrid DOM preservation Add JQHTML-CLASS-01 rule and fix redundant class names Improve code quality rules and resolve violations Remove legacy fatal error format in favor of unified 'fatal' error type Filter internal keys from window.rsxapp output Update button styling and comprehensive form/modal documentation Add conditional fly-in animation for modals Fix non-deterministic bundle compilation 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
651 lines
71 KiB
JavaScript
Executable File
651 lines
71 KiB
JavaScript
Executable File
"use strict";
|
|
|
|
function _e8211f5b_defineProperty(e, r, t) { return (r = _e8211f5b_toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
|
|
function _e8211f5b_toPropertyKey(t) { var i = _e8211f5b_toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
|
|
function _e8211f5b_toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
|
|
// @ROUTE-EXISTS-01-EXCEPTION - This file contains documentation examples with fictional route names
|
|
|
|
/**
|
|
* Rsx - Core JavaScript Runtime System
|
|
*
|
|
* The Rsx class is the central hub for the RSX JavaScript runtime, providing essential
|
|
* system-level utilities that all other framework components depend on. It serves as the
|
|
* foundation for the client-side framework, handling core operations that must be globally
|
|
* accessible and consistently available.
|
|
*
|
|
* Core Responsibilities:
|
|
* - Event System: Application-wide event bus for framework lifecycle and custom events
|
|
* - Environment Detection: Runtime environment identification (dev/production)
|
|
* - Route Management: Type-safe route generation and URL building
|
|
* - Unique ID Generation: Client-side unique identifier generation
|
|
* - Framework Bootstrap: Multi-phase initialization orchestration
|
|
* - Logging: Centralized logging interface (delegates to console_debug)
|
|
*
|
|
* The Rsx class deliberately keeps its scope limited to core utilities. Advanced features
|
|
* are delegated to specialized classes:
|
|
* - Manifest operations → Manifest class
|
|
* - Caching → Rsx_Cache class
|
|
* - AJAX/API calls → Ajax_* classes
|
|
* - Route proxies → Rsx_Route_Proxy class
|
|
* - Behaviors → Rsx_Behaviors class
|
|
*
|
|
* All methods are static - Rsx is never instantiated. It's available globally from the
|
|
* moment bundles load and remains constant throughout the application lifecycle.
|
|
*
|
|
* Usage Examples:
|
|
* ```javascript
|
|
* // Event system
|
|
* Rsx.on('app_ready', () => console.log('App initialized'));
|
|
* Rsx.trigger('custom_event', {data: 'value'});
|
|
*
|
|
* // Environment detection
|
|
* if (Rsx.is_dev()) { console.log('Development mode'); }
|
|
*
|
|
* // Route generation
|
|
* const url = Rsx.Route('Controller', 'action').url();
|
|
*
|
|
* // Unique IDs
|
|
* const uniqueId = Rsx.uid(); // e.g., "rsx_1234567890_1"
|
|
* ```
|
|
*
|
|
* @static
|
|
* @global
|
|
*/
|
|
class Rsx {
|
|
// Initialize event handlers storage
|
|
static _init_events() {
|
|
if (typeof Rsx._event_handlers === 'undefined') {
|
|
Rsx._event_handlers = {};
|
|
}
|
|
if (typeof Rsx._triggered_events === 'undefined') {
|
|
Rsx._triggered_events = {};
|
|
}
|
|
}
|
|
|
|
// Register an event handler
|
|
static on(event, callback) {
|
|
Rsx._init_events();
|
|
if (typeof callback !== 'function') {
|
|
throw new Error('Callback must be a function');
|
|
}
|
|
if (!Rsx._event_handlers[event]) {
|
|
Rsx._event_handlers[event] = [];
|
|
}
|
|
Rsx._event_handlers[event].push(callback);
|
|
|
|
// If this event was already triggered, call the callback immediately
|
|
if (Rsx._triggered_events[event]) {
|
|
console_debug('RSX_INIT', 'Triggering ' + event + ' for late registered callback');
|
|
callback(Rsx._triggered_events[event]);
|
|
}
|
|
}
|
|
|
|
// Trigger an event with optional data
|
|
static trigger(event) {
|
|
let data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
Rsx._init_events();
|
|
|
|
// Record that this event was triggered
|
|
Rsx._triggered_events[event] = data;
|
|
if (!Rsx._event_handlers[event]) {
|
|
return;
|
|
}
|
|
console_debug('RSX_INIT', 'Triggering ' + event + ' for ' + Rsx._event_handlers[event].length + ' callbacks');
|
|
|
|
// Call all registered handlers for this event in order
|
|
for (const callback of Rsx._event_handlers[event]) {
|
|
callback(data);
|
|
}
|
|
}
|
|
|
|
// Alias for trigger.refresh(''), should be called after major UI updates to apply such effects as
|
|
// underlining links to unimplemented # routes
|
|
static trigger_refresh() {
|
|
// Use Rsx.on('refresh', callback); to register a callback for refresh
|
|
this.trigger('refresh');
|
|
}
|
|
|
|
// Log to server that an event happened
|
|
static log(type) {
|
|
let message = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'notice';
|
|
Core_Log.log(type, message);
|
|
}
|
|
|
|
// Returns true if the app is being run in dev mode
|
|
// This should affect caching and some debug checks
|
|
static is_dev() {
|
|
return window.rsxapp.debug;
|
|
}
|
|
static is_prod() {
|
|
return !window.rsxapp.debug;
|
|
}
|
|
|
|
// Generates a unique number for the application instance
|
|
static uid() {
|
|
if (typeof Rsx._uid == undef) {
|
|
Rsx._uid = 0;
|
|
}
|
|
return Rsx._uid++;
|
|
}
|
|
|
|
// Storage for route definitions loaded from bundles
|
|
|
|
/**
|
|
* Define routes from bundled data
|
|
* Called by generated JavaScript in bundles
|
|
*/
|
|
static _define_routes(routes) {
|
|
// Merge routes into the global route storage
|
|
for (const class_name in routes) {
|
|
if (!Rsx._routes[class_name]) {
|
|
Rsx._routes[class_name] = {};
|
|
}
|
|
for (const method_name in routes[class_name]) {
|
|
Rsx._routes[class_name][method_name] = routes[class_name][method_name];
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Generate URL for a controller route
|
|
*
|
|
* This method generates URLs for controller actions by looking up route patterns
|
|
* and replacing parameters. It handles both regular routes and Ajax endpoints.
|
|
*
|
|
* If the route is not found in the route definitions, a default pattern is used:
|
|
* `/_/{controller}/{action}` with all parameters appended as query strings.
|
|
*
|
|
* Usage examples:
|
|
* ```javascript
|
|
* // Simple route without parameters (defaults to 'index' action)
|
|
* const url = Rsx.Route('Frontend_Index_Controller');
|
|
* // Returns: /dashboard
|
|
*
|
|
* // Route with explicit action
|
|
* const url = Rsx.Route('Frontend_Index_Controller', 'index');
|
|
* // Returns: /dashboard
|
|
*
|
|
* // Route with integer parameter (sets 'id')
|
|
* const url = Rsx.Route('Frontend_Client_View_Controller', 'view', 123);
|
|
* // Returns: /clients/view/123
|
|
*
|
|
* // Route with named parameters (object)
|
|
* const url = Rsx.Route('Frontend_Client_View_Controller', 'view', {id: 'C001'});
|
|
* // Returns: /clients/view/C001
|
|
*
|
|
* // Route with required and query parameters
|
|
* const url = Rsx.Route('Frontend_Client_View_Controller', 'view', {
|
|
* id: 'C001',
|
|
* tab: 'history'
|
|
* });
|
|
* // Returns: /clients/view/C001?tab=history
|
|
*
|
|
* // Route not found - uses default pattern
|
|
* const url = Rsx.Route('Unimplemented_Controller', 'some_action', {foo: 'bar'});
|
|
* // Returns: /_/Unimplemented_Controller/some_action?foo=bar
|
|
*
|
|
* // Placeholder route
|
|
* const url = Rsx.Route('Future_Controller', '#index');
|
|
* // Returns: #
|
|
* ```
|
|
*
|
|
* @param {string} class_name The controller class name (e.g., 'User_Controller')
|
|
* @param {string} [action_name='index'] The action/method name (defaults to 'index'). Use '#action' for placeholders.
|
|
* @param {number|Object} [params=null] Route parameters. Integer sets 'id', object provides named params.
|
|
* @returns {string} The generated URL
|
|
*/
|
|
static Route(class_name) {
|
|
let action_name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'index';
|
|
let params = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
|
|
// Normalize params to object
|
|
let params_obj = {};
|
|
if (typeof params === 'number') {
|
|
params_obj = {
|
|
id: params
|
|
};
|
|
} else if (params && typeof params === 'object') {
|
|
params_obj = params;
|
|
} else if (params !== null && params !== undefined) {
|
|
throw new Error('Params must be number, object, or null');
|
|
}
|
|
|
|
// Placeholder route: action starts with # means unimplemented/scaffolding
|
|
if (action_name.startsWith('#')) {
|
|
return '#';
|
|
}
|
|
|
|
// Check if route exists in definitions
|
|
let pattern;
|
|
if (Rsx._routes[class_name] && Rsx._routes[class_name][action_name]) {
|
|
pattern = Rsx._routes[class_name][action_name];
|
|
} else {
|
|
// Route not found - use default pattern /_/{controller}/{action}
|
|
pattern = `/_/${class_name}/${action_name}`;
|
|
}
|
|
|
|
// Generate URL from pattern
|
|
return Rsx._generate_url_from_pattern(pattern, params_obj);
|
|
}
|
|
|
|
/**
|
|
* Generate URL from route pattern by replacing parameters
|
|
*
|
|
* @param {string} pattern The route pattern (e.g., '/users/:id/view')
|
|
* @param {Object} params Parameters to fill into the route
|
|
* @returns {string} The generated URL
|
|
*/
|
|
static _generate_url_from_pattern(pattern, params) {
|
|
// Extract required parameters from the pattern
|
|
const required_params = [];
|
|
const matches = pattern.match(/:([a-zA-Z_][a-zA-Z0-9_]*)/g);
|
|
if (matches) {
|
|
// Remove the : prefix from each match
|
|
for (const match of matches) {
|
|
required_params.push(match.substring(1));
|
|
}
|
|
}
|
|
|
|
// Check for required parameters
|
|
const missing = [];
|
|
for (const required of required_params) {
|
|
if (!(required in params)) {
|
|
missing.push(required);
|
|
}
|
|
}
|
|
if (missing.length > 0) {
|
|
throw new Error(`Required parameters [${missing.join(', ')}] are missing for route ${pattern}`);
|
|
}
|
|
|
|
// Build the URL by replacing parameters
|
|
let url = pattern;
|
|
const used_params = {};
|
|
for (const param_name of required_params) {
|
|
const value = params[param_name];
|
|
// URL encode the value
|
|
const encoded_value = encodeURIComponent(value);
|
|
url = url.replace(':' + param_name, encoded_value);
|
|
used_params[param_name] = true;
|
|
}
|
|
|
|
// Collect any extra parameters for query string
|
|
const query_params = {};
|
|
for (const key in params) {
|
|
if (!used_params[key]) {
|
|
query_params[key] = params[key];
|
|
}
|
|
}
|
|
|
|
// Append query string if there are extra parameters
|
|
if (Object.keys(query_params).length > 0) {
|
|
const query_string = Object.entries(query_params).map(_ref => {
|
|
let [key, value] = _ref;
|
|
return `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
|
|
}).join('&');
|
|
url += '?' + query_string;
|
|
}
|
|
return url;
|
|
}
|
|
|
|
/**
|
|
* Internal: Call a specific method on all classes that have it
|
|
* Collects promises from return values and waits for all to resolve
|
|
* @param {string} method_name The method name to call on all classes
|
|
* @returns {Promise} Promise that resolves when all method calls complete
|
|
*/
|
|
static async _rsx_call_all_classes(method_name) {
|
|
const all_classes = Manifest.get_all_classes();
|
|
const classes_with_method = [];
|
|
const promise_pile = [];
|
|
for (const class_info of all_classes) {
|
|
const class_object = class_info.class_object;
|
|
const class_name = class_info.class_name;
|
|
|
|
// Check if this class has the method (static methods are on the class itself)
|
|
if (typeof class_object[method_name] === 'function') {
|
|
classes_with_method.push(class_name);
|
|
const return_value = await class_object[method_name]();
|
|
|
|
// Collect promises from return value
|
|
if (return_value instanceof Promise) {
|
|
promise_pile.push(return_value);
|
|
} else if (Array.isArray(return_value)) {
|
|
for (const item of return_value) {
|
|
if (item instanceof Promise) {
|
|
promise_pile.push(item);
|
|
}
|
|
}
|
|
}
|
|
if (Rsx.__stopped) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
if (classes_with_method.length > 0) {
|
|
console_debug('RSX_INIT', `${method_name}: ${classes_with_method.length} classes`);
|
|
}
|
|
|
|
// Await all promises before returning
|
|
if (promise_pile.length > 0) {
|
|
console_debug('RSX_INIT', `${method_name}: Awaiting ${promise_pile.length} promises`);
|
|
await Promise.all(promise_pile);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Internal: Execute multi-phase initialization for all registered classes
|
|
* This runs various initialization phases in order to properly set up the application
|
|
* @returns {Promise} Promise that resolves when all initialization phases complete
|
|
*/
|
|
static async _rsx_core_boot() {
|
|
if (Rsx.__booted) {
|
|
console.error('Rsx._rsx_core_boot called more than once');
|
|
return;
|
|
}
|
|
Rsx.__booted = true;
|
|
|
|
// Get all registered classes from the manifest
|
|
const all_classes = Manifest.get_all_classes();
|
|
console_debug('RSX_INIT', `Starting _rsx_core_boot with ${all_classes.length} classes`);
|
|
if (!all_classes || all_classes.length === 0) {
|
|
// No classes to initialize
|
|
shouldnt_happen('No classes registered in js - there should be at least the core framework classes');
|
|
return;
|
|
}
|
|
|
|
// Define initialization phases in order
|
|
const phases = [{
|
|
event: 'framework_core_define',
|
|
method: '_on_framework_core_define'
|
|
}, {
|
|
event: 'framework_modules_define',
|
|
method: '_on_framework_modules_define'
|
|
}, {
|
|
event: 'framework_core_init',
|
|
method: '_on_framework_core_init'
|
|
}, {
|
|
event: 'app_modules_define',
|
|
method: 'on_app_modules_define'
|
|
}, {
|
|
event: 'app_define',
|
|
method: 'on_app_define'
|
|
}, {
|
|
event: 'framework_modules_init',
|
|
method: '_on_framework_modules_init'
|
|
}, {
|
|
event: 'app_modules_init',
|
|
method: 'on_app_modules_init'
|
|
}, {
|
|
event: 'app_init',
|
|
method: 'on_app_init'
|
|
}, {
|
|
event: 'app_ready',
|
|
method: 'on_app_ready'
|
|
}];
|
|
|
|
// Execute each phase in order
|
|
for (const phase of phases) {
|
|
await Rsx._rsx_call_all_classes(phase.method);
|
|
if (Rsx.__stopped) {
|
|
return;
|
|
}
|
|
Rsx.trigger(phase.event);
|
|
}
|
|
|
|
// Ui refresh callbacks
|
|
Rsx.trigger_refresh();
|
|
|
|
// All phases complete
|
|
console_debug('RSX_INIT', 'Initialization complete');
|
|
|
|
// TODO: Find a good wait to wait for all jqhtml components to load, then trigger on_ready and on('ready') emulating the top level last syntax that jqhtml components operateas, but as a standard js class (such as a page class). The biggest question is, how do we efficiently choose only the top level jqhtml components. do we only consider components cretaed directly on blade templates? that seams reasonable...
|
|
|
|
// Trigger _debug_ready event - this is ONLY for tooling like rsx:debug
|
|
// DO NOT use this in application code - use on_app_ready() phase instead
|
|
// This event exists solely for debugging tools that need to run after full initialization
|
|
Rsx.trigger('_debug_ready');
|
|
}
|
|
|
|
/* Calling this stops the boot process. */
|
|
static async _rsx_core_boot_stop(reason) {
|
|
console.error(reason);
|
|
Rsx.__stopped = true;
|
|
}
|
|
|
|
/**
|
|
* Parse URL hash into key-value object
|
|
* Handles format: #key=value&key2=value2
|
|
*
|
|
* @returns {Object} Parsed hash parameters
|
|
*/
|
|
static _parse_hash() {
|
|
const hash = window.location.hash;
|
|
if (!hash || hash === '#') {
|
|
return {};
|
|
}
|
|
|
|
// Remove leading # and parse as query string
|
|
const hash_string = hash.substring(1);
|
|
const params = {};
|
|
const pairs = hash_string.split('&');
|
|
for (const pair of pairs) {
|
|
const [key, value] = pair.split('=');
|
|
if (key) {
|
|
params[decodeURIComponent(key)] = value ? decodeURIComponent(value) : '';
|
|
}
|
|
}
|
|
return params;
|
|
}
|
|
|
|
/**
|
|
* Serialize object into URL hash format
|
|
* Produces format: #key=value&key2=value2
|
|
*
|
|
* @param {Object} params Key-value pairs to encode
|
|
* @returns {string} Encoded hash string (with leading #, or empty string)
|
|
*/
|
|
static _serialize_hash(params) {
|
|
const pairs = [];
|
|
for (const key in params) {
|
|
const value = params[key];
|
|
if (value !== null && value !== undefined && value !== '') {
|
|
pairs.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
|
|
}
|
|
}
|
|
return pairs.length > 0 ? '#' + pairs.join('&') : '';
|
|
}
|
|
|
|
/**
|
|
* Get all page state from URL hash
|
|
*
|
|
* Usage:
|
|
* ```javascript
|
|
* const state = Rsx.get_all_page_state();
|
|
* // Returns: {dg_page: '2', dg_sort: 'name'}
|
|
* ```
|
|
*
|
|
* @returns {Object} All hash parameters as key-value pairs
|
|
*/
|
|
static get_all_page_state() {
|
|
return Rsx._parse_hash();
|
|
}
|
|
|
|
/**
|
|
* Get single value from URL hash state
|
|
*
|
|
* Usage:
|
|
* ```javascript
|
|
* const page = Rsx.get_page_state('dg_page');
|
|
* // Returns: '2' or null if not set
|
|
* ```
|
|
*
|
|
* @param {string} key The key to retrieve
|
|
* @returns {string|null} The value or null if not found
|
|
*/
|
|
static get_page_state(key) {
|
|
var _state$key;
|
|
const state = Rsx._parse_hash();
|
|
return (_state$key = state[key]) !== null && _state$key !== void 0 ? _state$key : null;
|
|
}
|
|
|
|
/**
|
|
* Set single value in URL hash state (replaces history, doesn't add)
|
|
*
|
|
* Usage:
|
|
* ```javascript
|
|
* Rsx.set_page_state('dg_page', 2);
|
|
* // URL becomes: http://example.com/page#dg_page=2
|
|
*
|
|
* Rsx.set_page_state('dg_page', null); // Remove key
|
|
* ```
|
|
*
|
|
* @param {string} key The key to set
|
|
* @param {string|number|null} value The value (null/empty removes the key)
|
|
*/
|
|
static set_page_state(key, value) {
|
|
const state = Rsx._parse_hash();
|
|
|
|
// Update or remove the key
|
|
if (value === null || value === undefined || value === '') {
|
|
delete state[key];
|
|
} else {
|
|
state[key] = String(value);
|
|
}
|
|
|
|
// Update URL without adding history
|
|
const new_hash = Rsx._serialize_hash(state);
|
|
const url = window.location.pathname + window.location.search + new_hash;
|
|
history.replaceState(null, '', url);
|
|
}
|
|
|
|
/**
|
|
* Set multiple values in URL hash state at once
|
|
*
|
|
* Usage:
|
|
* ```javascript
|
|
* Rsx.set_all_page_state({dg_page: 2, dg_sort: 'name'});
|
|
* // URL becomes: http://example.com/page#dg_page=2&dg_sort=name
|
|
* ```
|
|
*
|
|
* @param {Object} new_state Object with key-value pairs to set
|
|
*/
|
|
static set_all_page_state(new_state) {
|
|
const state = Rsx._parse_hash();
|
|
|
|
// Merge new state
|
|
for (const key in new_state) {
|
|
const value = new_state[key];
|
|
if (value === null || value === undefined || value === '') {
|
|
delete state[key];
|
|
} else {
|
|
state[key] = String(value);
|
|
}
|
|
}
|
|
|
|
// Update URL without adding history
|
|
const new_hash = Rsx._serialize_hash(state);
|
|
const url = window.location.pathname + window.location.search + new_hash;
|
|
history.replaceState(null, '', url);
|
|
}
|
|
|
|
/**
|
|
* Render an error in a DOM element
|
|
*
|
|
* Displays errors from Ajax calls in a standardized format. Handles different
|
|
* error types (fatal, validation, auth, generic) with appropriate formatting.
|
|
*
|
|
* Usage:
|
|
* ```javascript
|
|
* try {
|
|
* const result = await Controller.method();
|
|
* } catch (error) {
|
|
* Rsx.render_error(error, '#error_container');
|
|
* }
|
|
* ```
|
|
*
|
|
* @param {Error|Object} error - Error object from Ajax call
|
|
* @param {jQuery|string} container - jQuery element or selector for error display
|
|
*/
|
|
static render_error(error, container) {
|
|
const $container = $(container);
|
|
if (!$container.exists()) {
|
|
console.error('Rsx.render_error: Container not found', container);
|
|
return;
|
|
}
|
|
|
|
// Clear existing content
|
|
$container.empty();
|
|
let html = '';
|
|
|
|
// Handle different error types
|
|
if (error.type === 'fatal' && error.details) {
|
|
// Fatal PHP error with file/line/error
|
|
const details = error.details;
|
|
const file = details.file || 'Unknown file';
|
|
const line = details.line || '?';
|
|
const message = details.error || error.message || 'Fatal error occurred';
|
|
html = `
|
|
<div class="alert alert-danger" role="alert">
|
|
<h5>Uncaught Fatal Error in ${file}:${line}:</h5>
|
|
<p class="mb-0">${Rsx._escape_html(message)}</p>
|
|
</div>
|
|
`;
|
|
} else if (error.type === 'form_error' && error.details) {
|
|
// Validation errors - show unmatched errors only
|
|
// (matched errors should be handled by Form_Utils.apply_form_errors)
|
|
const errors = error.details;
|
|
const error_list = [];
|
|
for (const field in errors) {
|
|
error_list.push(errors[field]);
|
|
}
|
|
if (error_list.length > 0) {
|
|
html = `
|
|
<div class="alert alert-warning" role="alert">
|
|
<h5>Validation Errors:</h5>
|
|
<ul class="mb-0">
|
|
${error_list.map(err => `<li>${Rsx._escape_html(err)}</li>`).join('')}
|
|
</ul>
|
|
</div>
|
|
`;
|
|
}
|
|
} else if (error.type === 'auth_required' || error.type === 'unauthorized') {
|
|
// Authentication/authorization errors
|
|
const message = error.message || 'Authentication required';
|
|
html = `
|
|
<div class="alert alert-warning" role="alert">
|
|
<p class="mb-0">${Rsx._escape_html(message)}</p>
|
|
</div>
|
|
`;
|
|
} else if (error.type === 'network') {
|
|
// Network errors
|
|
const message = error.message || 'Unable to reach server. Please check your connection.';
|
|
html = `
|
|
<div class="alert alert-danger" role="alert">
|
|
<p class="mb-0">${Rsx._escape_html(message)}</p>
|
|
</div>
|
|
`;
|
|
} else {
|
|
// Generic/unknown error
|
|
const message = error.message || error.toString() || 'An unknown error occurred';
|
|
html = `
|
|
<div class="alert alert-danger" role="alert">
|
|
<p class="mb-0">${Rsx._escape_html(message)}</p>
|
|
</div>
|
|
`;
|
|
}
|
|
$container.html(html);
|
|
}
|
|
|
|
/**
|
|
* Escape HTML to prevent XSS in error messages
|
|
* @private
|
|
*/
|
|
static _escape_html(text) {
|
|
const div = document.createElement('div');
|
|
div.textContent = text;
|
|
return div.innerHTML;
|
|
}
|
|
}
|
|
// Gets set to true to interupt startup sequence
|
|
_e8211f5b_defineProperty(Rsx, "__stopped", false);
|
|
_e8211f5b_defineProperty(Rsx, "_routes", {});
|
|
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Rsx","_init_events","_event_handlers","_triggered_events","on","event","callback","Error","push","console_debug","trigger","data","arguments","length","undefined","trigger_refresh","log","type","message","Core_Log","is_dev","window","rsxapp","debug","is_prod","uid","_uid","undef","_define_routes","routes","class_name","_routes","method_name","Route","action_name","params","params_obj","id","startsWith","pattern","_generate_url_from_pattern","required_params","matches","match","substring","missing","required","join","url","used_params","param_name","value","encoded_value","encodeURIComponent","replace","query_params","key","Object","keys","query_string","entries","map","_ref","_rsx_call_all_classes","all_classes","Manifest","get_all_classes","classes_with_method","promise_pile","class_info","class_object","return_value","Promise","Array","isArray","item","__stopped","all","_rsx_core_boot","__booted","console","error","shouldnt_happen","phases","method","phase","_rsx_core_boot_stop","reason","_parse_hash","hash","location","hash_string","pairs","split","pair","decodeURIComponent","_serialize_hash","get_all_page_state","get_page_state","_state$key","state","set_page_state","String","new_hash","pathname","search","history","replaceState","set_all_page_state","new_state","render_error","container","$container","$","exists","empty","html","details","file","line","_escape_html","errors","error_list","field","err","toString","text","div","document","createElement","textContent","innerHTML","_e8211f5b_defineProperty"],"sources":["app/RSpade/Core/Js/Rsx.js"],"sourcesContent":["// @ROUTE-EXISTS-01-EXCEPTION - This file contains documentation examples with fictional route names\n\n/**\n * Rsx - Core JavaScript Runtime System\n *\n * The Rsx class is the central hub for the RSX JavaScript runtime, providing essential\n * system-level utilities that all other framework components depend on. It serves as the\n * foundation for the client-side framework, handling core operations that must be globally\n * accessible and consistently available.\n *\n * Core Responsibilities:\n * - Event System: Application-wide event bus for framework lifecycle and custom events\n * - Environment Detection: Runtime environment identification (dev/production)\n * - Route Management: Type-safe route generation and URL building\n * - Unique ID Generation: Client-side unique identifier generation\n * - Framework Bootstrap: Multi-phase initialization orchestration\n * - Logging: Centralized logging interface (delegates to console_debug)\n *\n * The Rsx class deliberately keeps its scope limited to core utilities. Advanced features\n * are delegated to specialized classes:\n * - Manifest operations → Manifest class\n * - Caching → Rsx_Cache class\n * - AJAX/API calls → Ajax_* classes\n * - Route proxies → Rsx_Route_Proxy class\n * - Behaviors → Rsx_Behaviors class\n *\n * All methods are static - Rsx is never instantiated. It's available globally from the\n * moment bundles load and remains constant throughout the application lifecycle.\n *\n * Usage Examples:\n * ```javascript\n * // Event system\n * Rsx.on('app_ready', () => console.log('App initialized'));\n * Rsx.trigger('custom_event', {data: 'value'});\n *\n * // Environment detection\n * if (Rsx.is_dev()) { console.log('Development mode'); }\n *\n * // Route generation\n * const url = Rsx.Route('Controller', 'action').url();\n *\n * // Unique IDs\n * const uniqueId = Rsx.uid(); // e.g., \"rsx_1234567890_1\"\n * ```\n *\n * @static\n * @global\n */\nclass Rsx {\n    // Gets set to true to interupt startup sequence\n    static __stopped = false;\n\n    // Initialize event handlers storage\n    static _init_events() {\n        if (typeof Rsx._event_handlers === 'undefined') {\n            Rsx._event_handlers = {};\n        }\n        if (typeof Rsx._triggered_events === 'undefined') {\n            Rsx._triggered_events = {};\n        }\n    }\n\n    // Register an event handler\n    static on(event, callback) {\n        Rsx._init_events();\n\n        if (typeof callback !== 'function') {\n            throw new Error('Callback must be a function');\n        }\n\n        if (!Rsx._event_handlers[event]) {\n            Rsx._event_handlers[event] = [];\n        }\n\n        Rsx._event_handlers[event].push(callback);\n\n        // If this event was already triggered, call the callback immediately\n        if (Rsx._triggered_events[event]) {\n            console_debug('RSX_INIT', 'Triggering ' + event + ' for late registered callback');\n            callback(Rsx._triggered_events[event]);\n        }\n    }\n\n    // Trigger an event with optional data\n    static trigger(event, data = {}) {\n        Rsx._init_events();\n\n        // Record that this event was triggered\n        Rsx._triggered_events[event] = data;\n\n        if (!Rsx._event_handlers[event]) {\n            return;\n        }\n\n        console_debug('RSX_INIT', 'Triggering ' + event + ' for ' + Rsx._event_handlers[event].length + ' callbacks');\n\n        // Call all registered handlers for this event in order\n        for (const callback of Rsx._event_handlers[event]) {\n            callback(data);\n        }\n    }\n\n    // Alias for trigger.refresh(''), should be called after major UI updates to apply such effects as\n    // underlining links to unimplemented # routes\n    static trigger_refresh() {\n        // Use Rsx.on('refresh', callback); to register a callback for refresh\n        this.trigger('refresh');\n    }\n\n    // Log to server that an event happened\n    static log(type, message = 'notice') {\n        Core_Log.log(type, message);\n    }\n\n    // Returns true if the app is being run in dev mode\n    // This should affect caching and some debug checks\n    static is_dev() {\n        return window.rsxapp.debug;\n    }\n\n    static is_prod() {\n        return !window.rsxapp.debug;\n    }\n\n    // Generates a unique number for the application instance\n    static uid() {\n        if (typeof Rsx._uid == undef) {\n            Rsx._uid = 0;\n        }\n        return Rsx._uid++;\n    }\n\n    // Storage for route definitions loaded from bundles\n    static _routes = {};\n\n    /**\n     * Define routes from bundled data\n     * Called by generated JavaScript in bundles\n     */\n    static _define_routes(routes) {\n        // Merge routes into the global route storage\n        for (const class_name in routes) {\n            if (!Rsx._routes[class_name]) {\n                Rsx._routes[class_name] = {};\n            }\n            for (const method_name in routes[class_name]) {\n                Rsx._routes[class_name][method_name] = routes[class_name][method_name];\n            }\n        }\n    }\n\n    /**\n     * Generate URL for a controller route\n     *\n     * This method generates URLs for controller actions by looking up route patterns\n     * and replacing parameters. It handles both regular routes and Ajax endpoints.\n     *\n     * If the route is not found in the route definitions, a default pattern is used:\n     * `/_/{controller}/{action}` with all parameters appended as query strings.\n     *\n     * Usage examples:\n     * ```javascript\n     * // Simple route without parameters (defaults to 'index' action)\n     * const url = Rsx.Route('Frontend_Index_Controller');\n     * // Returns: /dashboard\n     *\n     * // Route with explicit action\n     * const url = Rsx.Route('Frontend_Index_Controller', 'index');\n     * // Returns: /dashboard\n     *\n     * // Route with integer parameter (sets 'id')\n     * const url = Rsx.Route('Frontend_Client_View_Controller', 'view', 123);\n     * // Returns: /clients/view/123\n     *\n     * // Route with named parameters (object)\n     * const url = Rsx.Route('Frontend_Client_View_Controller', 'view', {id: 'C001'});\n     * // Returns: /clients/view/C001\n     *\n     * // Route with required and query parameters\n     * const url = Rsx.Route('Frontend_Client_View_Controller', 'view', {\n     *     id: 'C001',\n     *     tab: 'history'\n     * });\n     * // Returns: /clients/view/C001?tab=history\n     *\n     * // Route not found - uses default pattern\n     * const url = Rsx.Route('Unimplemented_Controller', 'some_action', {foo: 'bar'});\n     * // Returns: /_/Unimplemented_Controller/some_action?foo=bar\n     *\n     * // Placeholder route\n     * const url = Rsx.Route('Future_Controller', '#index');\n     * // Returns: #\n     * ```\n     *\n     * @param {string} class_name The controller class name (e.g., 'User_Controller')\n     * @param {string} [action_name='index'] The action/method name (defaults to 'index'). Use '#action' for placeholders.\n     * @param {number|Object} [params=null] Route parameters. Integer sets 'id', object provides named params.\n     * @returns {string} The generated URL\n     */\n    static Route(class_name, action_name = 'index', params = null) {\n        // Normalize params to object\n        let params_obj = {};\n        if (typeof params === 'number') {\n            params_obj = { id: params };\n        } else if (params && typeof params === 'object') {\n            params_obj = params;\n        } else if (params !== null && params !== undefined) {\n            throw new Error('Params must be number, object, or null');\n        }\n\n        // Placeholder route: action starts with # means unimplemented/scaffolding\n        if (action_name.startsWith('#')) {\n            return '#';\n        }\n\n        // Check if route exists in definitions\n        let pattern;\n        if (Rsx._routes[class_name] && Rsx._routes[class_name][action_name]) {\n            pattern = Rsx._routes[class_name][action_name];\n        } else {\n            // Route not found - use default pattern /_/{controller}/{action}\n            pattern = `/_/${class_name}/${action_name}`;\n        }\n\n        // Generate URL from pattern\n        return Rsx._generate_url_from_pattern(pattern, params_obj);\n    }\n\n    /**\n     * Generate URL from route pattern by replacing parameters\n     *\n     * @param {string} pattern The route pattern (e.g., '/users/:id/view')\n     * @param {Object} params Parameters to fill into the route\n     * @returns {string} The generated URL\n     */\n    static _generate_url_from_pattern(pattern, params) {\n        // Extract required parameters from the pattern\n        const required_params = [];\n        const matches = pattern.match(/:([a-zA-Z_][a-zA-Z0-9_]*)/g);\n        if (matches) {\n            // Remove the : prefix from each match\n            for (const match of matches) {\n                required_params.push(match.substring(1));\n            }\n        }\n\n        // Check for required parameters\n        const missing = [];\n        for (const required of required_params) {\n            if (!(required in params)) {\n                missing.push(required);\n            }\n        }\n\n        if (missing.length > 0) {\n            throw new Error(`Required parameters [${missing.join(', ')}] are missing for route ${pattern}`);\n        }\n\n        // Build the URL by replacing parameters\n        let url = pattern;\n        const used_params = {};\n\n        for (const param_name of required_params) {\n            const value = params[param_name];\n            // URL encode the value\n            const encoded_value = encodeURIComponent(value);\n            url = url.replace(':' + param_name, encoded_value);\n            used_params[param_name] = true;\n        }\n\n        // Collect any extra parameters for query string\n        const query_params = {};\n        for (const key in params) {\n            if (!used_params[key]) {\n                query_params[key] = params[key];\n            }\n        }\n\n        // Append query string if there are extra parameters\n        if (Object.keys(query_params).length > 0) {\n            const query_string = Object.entries(query_params)\n                .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)\n                .join('&');\n            url += '?' + query_string;\n        }\n\n        return url;\n    }\n\n    /**\n     * Internal: Call a specific method on all classes that have it\n     * Collects promises from return values and waits for all to resolve\n     * @param {string} method_name The method name to call on all classes\n     * @returns {Promise} Promise that resolves when all method calls complete\n     */\n    static async _rsx_call_all_classes(method_name) {\n        const all_classes = Manifest.get_all_classes();\n        const classes_with_method = [];\n        const promise_pile = [];\n\n        for (const class_info of all_classes) {\n            const class_object = class_info.class_object;\n            const class_name = class_info.class_name;\n\n            // Check if this class has the method (static methods are on the class itself)\n            if (typeof class_object[method_name] === 'function') {\n                classes_with_method.push(class_name);\n                const return_value = await class_object[method_name]();\n\n                // Collect promises from return value\n                if (return_value instanceof Promise) {\n                    promise_pile.push(return_value);\n                } else if (Array.isArray(return_value)) {\n                    for (const item of return_value) {\n                        if (item instanceof Promise) {\n                            promise_pile.push(item);\n                        }\n                    }\n                }\n\n                if (Rsx.__stopped) {\n                    return;\n                }\n            }\n        }\n\n        if (classes_with_method.length > 0) {\n            console_debug('RSX_INIT', `${method_name}: ${classes_with_method.length} classes`);\n        }\n\n        // Await all promises before returning\n        if (promise_pile.length > 0) {\n            console_debug('RSX_INIT', `${method_name}: Awaiting ${promise_pile.length} promises`);\n            await Promise.all(promise_pile);\n        }\n    }\n\n    /**\n     * Internal: Execute multi-phase initialization for all registered classes\n     * This runs various initialization phases in order to properly set up the application\n     * @returns {Promise} Promise that resolves when all initialization phases complete\n     */\n    static async _rsx_core_boot() {\n        if (Rsx.__booted) {\n            console.error('Rsx._rsx_core_boot called more than once');\n            return;\n        }\n\n        Rsx.__booted = true;\n\n        // Get all registered classes from the manifest\n        const all_classes = Manifest.get_all_classes();\n\n        console_debug('RSX_INIT', `Starting _rsx_core_boot with ${all_classes.length} classes`);\n\n        if (!all_classes || all_classes.length === 0) {\n            // No classes to initialize\n            shouldnt_happen('No classes registered in js - there should be at least the core framework classes');\n            return;\n        }\n\n        // Define initialization phases in order\n        const phases = [\n            { event: 'framework_core_define', method: '_on_framework_core_define' },\n            { event: 'framework_modules_define', method: '_on_framework_modules_define' },\n            { event: 'framework_core_init', method: '_on_framework_core_init' },\n            { event: 'app_modules_define', method: 'on_app_modules_define' },\n            { event: 'app_define', method: 'on_app_define' },\n            { event: 'framework_modules_init', method: '_on_framework_modules_init' },\n            { event: 'app_modules_init', method: 'on_app_modules_init' },\n            { event: 'app_init', method: 'on_app_init' },\n            { event: 'app_ready', method: 'on_app_ready' },\n        ];\n\n        // Execute each phase in order\n        for (const phase of phases) {\n            await Rsx._rsx_call_all_classes(phase.method);\n\n            if (Rsx.__stopped) {\n                return;\n            }\n\n            Rsx.trigger(phase.event);\n        }\n\n        // Ui refresh callbacks\n        Rsx.trigger_refresh();\n\n        // All phases complete\n        console_debug('RSX_INIT', 'Initialization complete');\n\n        // TODO: Find a good wait to wait for all jqhtml components to load, then trigger on_ready and on('ready') emulating the top level last syntax that jqhtml components operateas, but as a standard js class (such as a page class).  The biggest question is, how do we efficiently choose only the top level jqhtml components.  do we only consider components cretaed directly on blade templates? that seams reasonable...\n\n        // Trigger _debug_ready event - this is ONLY for tooling like rsx:debug\n        // DO NOT use this in application code - use on_app_ready() phase instead\n        // This event exists solely for debugging tools that need to run after full initialization\n        Rsx.trigger('_debug_ready');\n    }\n\n    /* Calling this stops the boot process. */\n    static async _rsx_core_boot_stop(reason) {\n        console.error(reason);\n        Rsx.__stopped = true;\n    }\n\n    /**\n     * Parse URL hash into key-value object\n     * Handles format: #key=value&key2=value2\n     *\n     * @returns {Object} Parsed hash parameters\n     */\n    static _parse_hash() {\n        const hash = window.location.hash;\n        if (!hash || hash === '#') {\n            return {};\n        }\n\n        // Remove leading # and parse as query string\n        const hash_string = hash.substring(1);\n        const params = {};\n\n        const pairs = hash_string.split('&');\n        for (const pair of pairs) {\n            const [key, value] = pair.split('=');\n            if (key) {\n                params[decodeURIComponent(key)] = value ? decodeURIComponent(value) : '';\n            }\n        }\n\n        return params;\n    }\n\n    /**\n     * Serialize object into URL hash format\n     * Produces format: #key=value&key2=value2\n     *\n     * @param {Object} params Key-value pairs to encode\n     * @returns {string} Encoded hash string (with leading #, or empty string)\n     */\n    static _serialize_hash(params) {\n        const pairs = [];\n        for (const key in params) {\n            const value = params[key];\n            if (value !== null && value !== undefined && value !== '') {\n                pairs.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);\n            }\n        }\n\n        return pairs.length > 0 ? '#' + pairs.join('&') : '';\n    }\n\n    /**\n     * Get all page state from URL hash\n     *\n     * Usage:\n     * ```javascript\n     * const state = Rsx.get_all_page_state();\n     * // Returns: {dg_page: '2', dg_sort: 'name'}\n     * ```\n     *\n     * @returns {Object} All hash parameters as key-value pairs\n     */\n    static get_all_page_state() {\n        return Rsx._parse_hash();\n    }\n\n    /**\n     * Get single value from URL hash state\n     *\n     * Usage:\n     * ```javascript\n     * const page = Rsx.get_page_state('dg_page');\n     * // Returns: '2' or null if not set\n     * ```\n     *\n     * @param {string} key The key to retrieve\n     * @returns {string|null} The value or null if not found\n     */\n    static get_page_state(key) {\n        const state = Rsx._parse_hash();\n        return state[key] ?? null;\n    }\n\n    /**\n     * Set single value in URL hash state (replaces history, doesn't add)\n     *\n     * Usage:\n     * ```javascript\n     * Rsx.set_page_state('dg_page', 2);\n     * // URL becomes: http://example.com/page#dg_page=2\n     *\n     * Rsx.set_page_state('dg_page', null); // Remove key\n     * ```\n     *\n     * @param {string} key The key to set\n     * @param {string|number|null} value The value (null/empty removes the key)\n     */\n    static set_page_state(key, value) {\n        const state = Rsx._parse_hash();\n\n        // Update or remove the key\n        if (value === null || value === undefined || value === '') {\n            delete state[key];\n        } else {\n            state[key] = String(value);\n        }\n\n        // Update URL without adding history\n        const new_hash = Rsx._serialize_hash(state);\n        const url = window.location.pathname + window.location.search + new_hash;\n        history.replaceState(null, '', url);\n    }\n\n    /**\n     * Set multiple values in URL hash state at once\n     *\n     * Usage:\n     * ```javascript\n     * Rsx.set_all_page_state({dg_page: 2, dg_sort: 'name'});\n     * // URL becomes: http://example.com/page#dg_page=2&dg_sort=name\n     * ```\n     *\n     * @param {Object} new_state Object with key-value pairs to set\n     */\n    static set_all_page_state(new_state) {\n        const state = Rsx._parse_hash();\n\n        // Merge new state\n        for (const key in new_state) {\n            const value = new_state[key];\n            if (value === null || value === undefined || value === '') {\n                delete state[key];\n            } else {\n                state[key] = String(value);\n            }\n        }\n\n        // Update URL without adding history\n        const new_hash = Rsx._serialize_hash(state);\n        const url = window.location.pathname + window.location.search + new_hash;\n        history.replaceState(null, '', url);\n    }\n\n    /**\n     * Render an error in a DOM element\n     *\n     * Displays errors from Ajax calls in a standardized format. Handles different\n     * error types (fatal, validation, auth, generic) with appropriate formatting.\n     *\n     * Usage:\n     * ```javascript\n     * try {\n     *     const result = await Controller.method();\n     * } catch (error) {\n     *     Rsx.render_error(error, '#error_container');\n     * }\n     * ```\n     *\n     * @param {Error|Object} error - Error object from Ajax call\n     * @param {jQuery|string} container - jQuery element or selector for error display\n     */\n    static render_error(error, container) {\n        const $container = $(container);\n\n        if (!$container.exists()) {\n            console.error('Rsx.render_error: Container not found', container);\n            return;\n        }\n\n        // Clear existing content\n        $container.empty();\n\n        let html = '';\n\n        // Handle different error types\n        if (error.type === 'fatal' && error.details) {\n            // Fatal PHP error with file/line/error\n            const details = error.details;\n            const file = details.file || 'Unknown file';\n            const line = details.line || '?';\n            const message = details.error || error.message || 'Fatal error occurred';\n\n            html = `\n                <div class=\"alert alert-danger\" role=\"alert\">\n                    <h5>Uncaught Fatal Error in ${file}:${line}:</h5>\n                    <p class=\"mb-0\">${Rsx._escape_html(message)}</p>\n                </div>\n            `;\n        } else if (error.type === 'form_error' && error.details) {\n            // Validation errors - show unmatched errors only\n            // (matched errors should be handled by Form_Utils.apply_form_errors)\n            const errors = error.details;\n            const error_list = [];\n\n            for (const field in errors) {\n                error_list.push(errors[field]);\n            }\n\n            if (error_list.length > 0) {\n                html = `\n                    <div class=\"alert alert-warning\" role=\"alert\">\n                        <h5>Validation Errors:</h5>\n                        <ul class=\"mb-0\">\n                            ${error_list.map(err => `<li>${Rsx._escape_html(err)}</li>`).join('')}\n                        </ul>\n                    </div>\n                `;\n            }\n        } else if (error.type === 'auth_required' || error.type === 'unauthorized') {\n            // Authentication/authorization errors\n            const message = error.message || 'Authentication required';\n            html = `\n                <div class=\"alert alert-warning\" role=\"alert\">\n                    <p class=\"mb-0\">${Rsx._escape_html(message)}</p>\n                </div>\n            `;\n        } else if (error.type === 'network') {\n            // Network errors\n            const message = error.message || 'Unable to reach server. Please check your connection.';\n            html = `\n                <div class=\"alert alert-danger\" role=\"alert\">\n                    <p class=\"mb-0\">${Rsx._escape_html(message)}</p>\n                </div>\n            `;\n        } else {\n            // Generic/unknown error\n            const message = error.message || error.toString() || 'An unknown error occurred';\n            html = `\n                <div class=\"alert alert-danger\" role=\"alert\">\n                    <p class=\"mb-0\">${Rsx._escape_html(message)}</p>\n                </div>\n            `;\n        }\n\n        $container.html(html);\n    }\n\n    /**\n     * Escape HTML to prevent XSS in error messages\n     * @private\n     */\n    static _escape_html(text) {\n        const div = document.createElement('div');\n        div.textContent = text;\n        return div.innerHTML;\n    }\n}\n"],"mappings":"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","ignoreList":[]}
|