json-object-editor 0.10.665 → 0.10.670

package/server/schemas/ai_prompt.js

@@ -69,8 +69,15 @@ var schema = {
         return _joe.Filter.Options.status();
     },
     filters:function(i){
-        
-        return _joe.Filter.Options.tags();
+        var schemas = [];
+        var subs = [];
+        _joe.current.list.map(function(status){
+            schemas = schemas.concat(status.datasets||[]);
+        });
+        (new Set(schemas)).map(function(schema){
+            subs.push({name:schema,filter:{datasets:{$in:[schema]}}})
+        });
+        return subs.concat(_joe.Filter.Options.tags({group:'tags',collapsed:true}));
     },
     stripeColor: function(item) {
         //use the stripe color from ai_assistant status object if it has one
@@ -98,8 +105,19 @@ var schema = {
        'name',
         'info',
         {name:"prompt_method",placeholder:"name of method to call in plugin", comment:'use executeJOEAiPrompt to use the JOE ui here for all smarts', default:"executeJOEAiPrompt",display:"Prompt Plugin Method",type:'text'},
-        {name:'content_items',type:'objectList',
-            properties:['itemtype','reference']
+        {name:'content_items',type:'objectList',display:'Content Items',
+            properties:['itemtype','reference'],
+            comment:`
+                <div>
+                    <p>Define which objects are automatically passed when running this prompt via <code>select_prompt</code>.</p>
+                    <ul>
+                        <li><b><code>itemtype</code></b> - Schema name (e.g., <code>"task"</code>)</li>
+                        <li><b><code>reference</code></b> - Parameter name for the object's <code>_id</code> (e.g., <code>"task"</code>)</li>
+                    </ul>
+                    <p>When running from a matching object: <code>params[reference]</code> = object <code>_id</code>, <code>content_objects[itemtype]</code> = full object (available in helper functions).</p>
+                    <p><b>Note:</b> Only objects matching the current object's <code>itemtype</code> are auto-passed. For multiple objects, call programmatically or load in helper functions.</p>
+                </div>
+            `
         },
         {section_start:'Input'},
             {name: 'functions', type: 'code', display: 'Helper Functions', language:'javascript',comment: `

package/server/schemas/report.js

@@ -113,7 +113,7 @@ var schema = {
             }},
         {section_end:'Template'},
         {section_start:'preview'},
-            {name:'examples', type:'content',run:function(item){
+            {name:'examples', reloadable:true,type:'content',run:function(item){
                 return $J.schema('report').methods.renderPreviews(item);
             }
             /*run:function(item){

package/server/schemas/task.js

@@ -193,6 +193,7 @@ var task = function(){return{
             'name',
             'info',
             {extend:'description',specs:{
+                queryJobs:true,
                 ai:{prompt:'Summarize the task in a few sentences. Take into account the project the task is associated with if there is one.'}}
             },
         {section_end:'overview'},

package/web-components/field-jobs-container.js

@@ -0,0 +1,224 @@
+class FieldJobsContainer extends HTMLElement {
+  constructor() {
+    super();
+    this.objectId = null;
+    this.fieldName = null;
+    this.jobs = [];
+    this.updateInterval = null;
+  }
+
+  static get observedAttributes() {
+    return ['data-object-id', 'data-field-name'];
+  }
+
+  connectedCallback() {
+    this.objectId = this.getAttribute('data-object-id');
+    this.fieldName = this.getAttribute('data-field-name');
+    this.render();
+    this.startElapsedTimeUpdates();
+    
+    // Immediately poll for jobs on connect
+    if (this.objectId && this.fieldName) {
+      var self = this;
+      $.get('/API/aijobs/' + encodeURIComponent(this.objectId) + '/' + encodeURIComponent(this.fieldName))
+        .then(function(data) {
+          if (data && data.jobs && Array.isArray(data.jobs)) {
+            self.updateJobs(data.jobs);
+          } else {
+            self.updateJobs([]);
+          }
+        })
+        .fail(function(err) {
+          // Silently fail - will retry on next poll
+          if (window.DEBUG_MODE || (window.$c && $c.DEBUG_MODE)) {
+            console.warn('[field-jobs-container] initial poll failed:', err);
+          }
+        });
+    }
+  }
+
+  disconnectedCallback() {
+    this.stopElapsedTimeUpdates();
+  }
+
+  attributeChangedCallback(name, oldValue, newValue) {
+    if (name === 'data-object-id') {
+      this.objectId = newValue;
+    } else if (name === 'data-field-name') {
+      this.fieldName = newValue;
+    }
+    if (this.objectId && this.fieldName) {
+      this.render();
+    }
+  }
+
+  /**
+   * Update jobs from server response
+   */
+  updateJobs(jobs) {
+    if (!Array.isArray(jobs)) {
+      jobs = [];
+    }
+    this.jobs = jobs;
+    this.render();
+  }
+
+  /**
+   * Calculate elapsed seconds from startTime
+   */
+  calculateElapsed(startTime) {
+    if (!startTime) return 0;
+    try {
+      var start = new Date(startTime);
+      var now = new Date();
+      var elapsedMs = now - start;
+      return Math.floor(elapsedMs / 1000);
+    } catch (e) {
+      return 0;
+    }
+  }
+
+  /**
+   * Start elapsed time updates (every second)
+   */
+  startElapsedTimeUpdates() {
+    if (this.updateInterval) return; // Already running
+    
+    this.updateInterval = setInterval(() => {
+      // Check if we have any active jobs
+      var hasActive = this.jobs.some(function(job) {
+        return (job.status === 'running' || job.status === 'starting') &&
+               (job.total == null || job.progress == null || job.progress < job.total);
+      });
+      
+      if (hasActive) {
+        // Force re-render to update elapsed times
+        this.render();
+      } else {
+        // Stop if no active jobs
+        this.stopElapsedTimeUpdates();
+      }
+    }, 1000);
+  }
+
+  /**
+   * Stop elapsed time updates
+   */
+  stopElapsedTimeUpdates() {
+    if (this.updateInterval) {
+      clearInterval(this.updateInterval);
+      this.updateInterval = null;
+    }
+  }
+
+  /**
+   * Render the component
+   */
+  render() {
+    // Build endpoint URL for token link (if we have both objectId and fieldName)
+    var endpointUrl = null;
+    var tokenLinkHtml = '';
+    var fullToken = null;
+    
+    // Try to get a sample token from jobs, or construct lookup key
+    if (this.jobs.length > 0 && this.jobs[0].token) {
+      fullToken = this.jobs[0].token;
+    } else if (this.objectId && this.fieldName) {
+      // If no jobs, show lookup key format
+      fullToken = this.objectId + '_' + this.fieldName;
+    }
+    
+    if (this.objectId && this.fieldName) {
+      endpointUrl = '/API/aijobs/' + encodeURIComponent(this.objectId) + '/' + encodeURIComponent(this.fieldName);
+      var titleAttr = fullToken ? 'title="' + fullToken.replace(/"/g, '&quot;') + '"' : 'title="View endpoint"';
+      tokenLinkHtml = '<a href="' + endpointUrl + '" target="_blank" class="field-jobs-token-link" ' + titleAttr + '>[' + this.objectId.substring(0, 8) + '...|' + this.fieldName + ']</a>';
+    }
+    
+    if (!this.objectId || !this.fieldName) {
+      var html = '<div class="field-jobs-title">';
+      html += '<span class="field-jobs-title-text">0 active jobs</span>';
+      html += tokenLinkHtml;
+      html += '</div>';
+      this.innerHTML = html;
+      return;
+    }
+
+    // Filter active jobs (for count)
+    var activeJobs = this.jobs.filter(function(job) {
+      return job.status !== 'complete' && job.status !== 'error';
+    });
+
+    // Update token link with full token if we have jobs (recalculate in case jobs were added)
+    if (this.jobs.length > 0 && this.jobs[0].token) {
+      fullToken = this.jobs[0].token;
+      if (endpointUrl) {
+        var titleAttr = 'title="' + fullToken.replace(/"/g, '&quot;') + '"';
+        tokenLinkHtml = '<a href="' + endpointUrl + '" target="_blank" class="field-jobs-token-link" ' + titleAttr + '>[' + this.objectId.substring(0, 8) + '...|' + this.fieldName + ']</a>';
+      }
+    }
+
+    // Build HTML
+    var html = '';
+    
+    // Title with active job count and token link on the right
+    html += '<div class="field-jobs-title">';
+    html += '<span class="field-jobs-title-text">' + activeJobs.length + ' active job' + (activeJobs.length !== 1 ? 's' : '') + '</span>';
+    html += tokenLinkHtml;
+    html += '</div>';
+    
+    // Job rows (show all jobs, including completed)
+    if (this.jobs.length > 0) {
+      var self = this;
+      this.jobs.forEach(function(job) {
+        var jobName = job.promptName || job.promptId || 'Job';
+        var elapsedSeconds = job.elapsedSeconds != null ? job.elapsedSeconds : self.calculateElapsed(job.startTime);
+        var elapsedText = elapsedSeconds > 0 ? ' (' + elapsedSeconds + 's)' : '';
+        
+        // Status text (capitalized)
+        var statusText = '';
+        if (job.status) {
+          statusText = ' - ' + job.status.charAt(0).toUpperCase() + job.status.slice(1);
+        }
+        
+        var percent = null;
+        if (job.total != null && job.progress != null) {
+          percent = Math.round((job.progress / job.total) * 100);
+        }
+        
+        var statusClass = '';
+        if (job.status === 'complete') {
+          statusClass = 'field-jobs-complete';
+          percent = 100;
+        } else if (job.status === 'error') {
+          statusClass = 'field-jobs-error';
+        }
+        
+        html += '<div class="field-jobs-row ' + statusClass + '">';
+        html += '<div class="field-jobs-row-content">';
+        html += '<div class="field-jobs-row-title">' + jobName + statusText + elapsedText + '</div>';
+        html += '<div class="field-jobs-row-message">' + (job.message || '') + '</div>';
+        html += '</div>';
+        if (percent != null) {
+          html += '<div class="field-jobs-row-percent">' + percent + '%</div>';
+        } else {
+          html += '<div class="field-jobs-row-percent">—</div>';
+        }
+        html += '</div>';
+      });
+    }
+    
+    this.innerHTML = html;
+    
+    // Restart elapsed time updates if we have active jobs
+    var hasActive = this.jobs.some(function(job) {
+      return (job.status === 'running' || job.status === 'starting') &&
+             (job.total == null || job.progress == null || job.progress < job.total);
+    });
+    
+    if (hasActive) {
+      this.startElapsedTimeUpdates();
+    }
+  }
+}
+
+window.customElements.define('field-jobs-container', FieldJobsContainer);

package/web-components/joe-workflow-widget.js

@@ -0,0 +1,314 @@
+class JoeWorkflowWidget extends HTMLElement {
+  constructor() {
+    super();
+    this.updateTimer = null;
+    this._rendering = false;
+    this._renderScheduled = false;
+    this.config = this.getDefaultConfig();
+    this.joeIndex = null;
+    this.widgetFieldName = null;
+    this._liveObj = null; // constructed snapshot for live completion when autoUpdate enabled
+  }
+
+  static get observedAttributes() {
+    return ['schema', '_id'];
+  }
+
+  connectedCallback() {
+    this.schemaName = this.getAttribute('schema');
+    this.objectId = this.getAttribute('_id');
+    this.classList.add('joe-workflow-widget');
+    
+    // Get workflow config from field definition
+    this.workflowField = this.closest('.joe-object-field');
+    if (this.workflowField) {
+      var fieldName = this.workflowField.getAttribute('data-name');
+      this.widgetFieldName = fieldName;
+      if (fieldName && window._joe) {
+        var fieldDef = window._joe.getField(fieldName);
+        this.config = (fieldDef && fieldDef.workflow_config) || this.getDefaultConfig();
+      }
+    }
+    
+    this.config = this.config || this.getDefaultConfig();
+
+    // Determine joeIndex for navigation and updates
+    try{
+      var overlay = this.closest('.joe-overlay');
+      if(overlay && overlay.getAttribute('data-joeindex') !== null){
+        this.joeIndex = parseInt(overlay.getAttribute('data-joeindex'), 10);
+        if(isNaN(this.joeIndex)){ this.joeIndex = null; }
+      }
+    }catch(e){}
+    
+    // Get schema name from JOE if not provided
+    if (!this.schemaName && window._joe && window._joe.current && window._joe.current.schema) {
+      this.schemaName = window._joe.current.schema.__schemaname || window._joe.current.schema.name;
+    }
+    
+    this.scheduleRender();
+    this.setupUpdateListener();
+  }
+
+  getDefaultConfig() {
+    return {
+      sections: 'all',
+      fields: 'all',
+      excludeSections: ['system'],
+      excludeFields: ['_id', 'created', 'joeUpdated', 'itemtype', 'tags', 'status'],
+      mustBeTrue: [],
+      autoUpdate: false  // Disabled by default to prevent lockups
+    };
+  }
+
+  setupUpdateListener() {
+    // Only set up listeners if autoUpdate is enabled
+    if (!this.config || !this.config.autoUpdate) {
+      return;
+    }
+
+    // Simplest live update (no tech debt):
+    // On change, compute a constructed snapshot once (debounced) and re-render from that.
+    // Critically, we never call _jco(true) from render() to avoid re-entrancy loops.
+    if(this.joeIndex === null || !window.getJoe){ return; }
+    var self = this;
+    var overlay = this.closest('.joe-overlay');
+    if(!overlay){ return; }
+    this._onFormChange = function(ev){
+      if(ev && ev.target && self.contains(ev.target)){ return; }
+      clearTimeout(self.updateTimer);
+      self.updateTimer = setTimeout(function(){
+        try{
+          var j = getJoe(self.joeIndex);
+          self._liveObj = (j && j.constructObjectFromFields) ? j.constructObjectFromFields(self.joeIndex) : null;
+        }catch(e){
+          self._liveObj = null;
+        }
+        self.scheduleRender();
+      }, 350);
+    };
+    overlay.addEventListener('change', this._onFormChange, true);
+  }
+
+  disconnectedCallback() {
+    try{
+      var overlay = this.closest('.joe-overlay');
+      if(overlay && this._onFormChange){
+        overlay.removeEventListener('change', this._onFormChange, true);
+      }
+    }catch(e){}
+    if (this.updateTimer) {
+      clearTimeout(this.updateTimer);
+    }
+  }
+
+  attributeChangedCallback(attr, oldValue, newValue) {
+    if (oldValue !== newValue) {
+      if (attr === 'schema') {
+        this.schemaName = newValue;
+      } else if (attr === '_id') {
+        this.objectId = newValue;
+      }
+      this.scheduleRender();
+    }
+  }
+
+  scheduleRender() {
+    if (this._renderScheduled) {
+      return;
+    }
+    this._renderScheduled = true;
+    var self = this;
+    // Defer to avoid re-entrancy with JOE render/construct cycles
+    setTimeout(function() {
+      self._renderScheduled = false;
+      self.render();
+    }, 0);
+  }
+
+  render() {
+    var self = this;
+    if (this._rendering) {
+      return;
+    }
+    this._rendering = true;
+    var joe = window._joe;
+    if (!joe || !joe.current) {
+      this.innerHTML = '<div class="joe-workflow-error">Workflow widget requires active JOE instance</div>';
+      this._rendering = false;
+      return;
+    }
+
+    var fields = joe.current.fields || [];
+    var sections = joe.current.sections || {};
+    // IMPORTANT: Do NOT call _jco(true) here. It triggers constructObjectFromFields which can
+    // cause re-entrant rerenders / attributeChangedCallback loops and lock up the UI.
+    // Use the live object snapshot. (When autoUpdate is re-enabled later, we can switch to a safer source.)
+    var currentObj = this._liveObj || joe.current.object || {};
+    
+    // Filter sections to show
+    var sectionsToShow = [];
+    if (this.config.sections === 'all') {
+      for (var secId in sections) {
+        if (this.config.excludeSections && this.config.excludeSections.indexOf(secId) !== -1) continue;
+        if (secId === 'system') continue;
+        if (!sections[secId] || !sections[secId].fields || !sections[secId].fields.length) continue;
+        sectionsToShow.push(secId);
+      }
+    } else if (Array.isArray(this.config.sections)) {
+      sectionsToShow = this.config.sections.filter(function(secId) {
+        return sections[secId] && 
+               (!self.config.excludeSections || self.config.excludeSections.indexOf(secId) === -1);
+      });
+    }
+
+    // Calculate progress for each section
+    var sectionProgress = {};
+    sectionsToShow.forEach(function(sectionId) {
+      var section = sections[sectionId];
+      if (!section) return;
+
+      var fieldsInSection = section.fields || [];
+      if (fieldsInSection.length === 0) return;
+
+      var completed = 0;
+      var totalCount = 0;
+      var missing = [];
+      fieldsInSection.forEach(function(fname) {
+        var field = joe.getField(fname) || { name: fname, type: 'text' };
+        var ftype = (joe.propAsFuncOrValue && joe.propAsFuncOrValue(field.type, currentObj)) || field.type || 'text';
+        ftype = (ftype || '').toString().toLowerCase();
+        // Never include content fields in completion counts (widgets, labels, etc).
+        if(ftype === 'content'){ return; }
+        if(self.config.excludeFields && self.config.excludeFields.indexOf(field.name) !== -1){ return; }
+        if(self.config.fields === 'requiredOnly' && !joe.propAsFuncOrValue(field.required, currentObj)){ return; }
+        if(field.hidden && joe.propAsFuncOrValue(field.hidden, currentObj)){ return; }
+        if(field.condition && !joe.propAsFuncOrValue(field.condition, currentObj)){ return; }
+        totalCount++;
+        if (self.isFieldComplete(field, currentObj)) {
+          completed++;
+        }else{
+          missing.push(field.display || field.label || field.name);
+        }
+      });
+
+      if(!totalCount){ return; }
+      var percentage = Math.round((completed / totalCount) * 100);
+      sectionProgress[sectionId] = {
+        name: section.name || sectionId,
+        completed: completed,
+        total: totalCount,
+        percentage: percentage,
+        isComplete: percentage === 100,
+        anchor: section.anchor || sectionId,
+        missing: missing
+      };
+    });
+
+    // Render widget HTML
+    var widgetTitle = this.config.title;
+    if (!widgetTitle && this.schemaName) {
+      // Capitalize first letter of schema name
+      widgetTitle = (this.schemaName.charAt(0).toUpperCase() + this.schemaName.slice(1)) + ' Workflow';
+    }
+    if (!widgetTitle) {
+      widgetTitle = 'Workflow'; // fallback
+    }
+    var html = '<div class="joe-workflow-widget-header">' + widgetTitle + '</div>';
+
+    var hasSections = false;
+    sectionsToShow.forEach(function(sectionId) {
+      var progress = sectionProgress[sectionId];
+      if (!progress) return;
+      hasSections = true;
+
+      var statusHtml = progress.isComplete 
+        ? '<span class="joe-workflow-checkmark" title="Complete">✓</span>'
+        : '<span class="joe-workflow-percentage" title="' + progress.completed + ' of ' + progress.total + ' fields complete">' + progress.percentage + '%</span>';
+
+      var ji = (self.joeIndex !== null ? self.joeIndex : 0);
+      var safeSectionIdHtml = (sectionId || '').toString()
+        .replace(/&/g, '&amp;')
+        .replace(/"/g, '&quot;');
+      // Use double-quotes inside gotoSection(...) to avoid JS escaping issues.
+      var clickAction = 'onclick="try{ getJoe(' + ji + ').gotoSection(&quot;' + safeSectionIdHtml + '&quot;); }catch(e){}" style="cursor:pointer;"';
+
+      var tip = '';
+      if(progress.missing && progress.missing.length){
+        tip = progress.missing.join(' | ')
+          .replace(/&/g, '&amp;')
+          .replace(/"/g, '&quot;')
+          .replace(/</g, '&lt;')
+          .replace(/>/g, '&gt;');
+      }
+
+      html += '<div class="joe-workflow-section" ' + clickAction + (tip ? (' title="' + tip + '"') : '') + '>';
+      html += '<div class="joe-workflow-section-label">' + progress.name + '</div>';
+      html += '<div class="joe-workflow-section-status">' + statusHtml + '</div>';
+      html += '</div>';
+    });
+
+    if (!hasSections) {
+      html += '<div class="joe-workflow-empty">No sections to track</div>';
+    }
+
+    this.innerHTML = html;
+    this._rendering = false;
+  }
+
+  isFieldComplete(field, obj) {
+    var value = obj[field.name];
+    var fieldType = (field.type || '').toLowerCase();
+    var mustBeTrue = this.config.mustBeTrue && Array.isArray(this.config.mustBeTrue) 
+                     && this.config.mustBeTrue.indexOf(field.name) !== -1;
+
+    if (value === undefined || value === null) {
+      return false;
+    }
+
+    switch (fieldType) {
+      case 'text':
+      case 'rendering':
+      case 'code':
+      case 'wysiwyg':
+      case 'url':
+        return typeof value === 'string' && value.trim().length > 0;
+
+      case 'objectreference':
+        return Array.isArray(value) ? value.length > 0 : !!value;
+
+      case 'objectlist':
+        return Array.isArray(value) && value.length > 0;
+
+      case 'number':
+        return typeof value === 'number' && !isNaN(value);
+
+      case 'boolean':
+        if (mustBeTrue) {
+          return value === true;
+        }
+        return typeof value === 'boolean';
+
+      case 'date':
+      case 'date-time':
+        return !!value;
+
+      case 'select':
+        return value !== '' && value !== null && value !== undefined;
+
+      case 'uploader':
+        return Array.isArray(value) && value.length > 0;
+
+      default:
+        if (Array.isArray(value)) {
+          return value.length > 0;
+        }
+        if (typeof value === 'object') {
+          return Object.keys(value).length > 0;
+        }
+        return !!value;
+    }
+  }
+}
+
+window.customElements.define('joe-workflow-widget', JoeWorkflowWidget);