Merge pull request '[jsdoc] Remove model field if empty' (#46) from fix/js-doc into develop

Reviewed-on: https://git.onlyoffice.com/ONLYOFFICE/build_tools/pulls/46

scripts/deploy_desktop.py

@@ -184,6 +184,7 @@ def make():
         base.copy_file(git_dir + "/desktop-apps/win-linux/extras/projicons/" + apps_postfix + "/projicons.exe", root_dir + "/DesktopEditors.exe")
         if not isWindowsXP:
           base.copy_file(git_dir + "/desktop-apps/win-linux/extras/update-daemon/" + apps_postfix + "/updatesvc.exe", root_dir + "/updatesvc.exe")
+        else:
           base.copy_file(git_dir + "/desktop-apps/win-linux/extras/online-installer/" + apps_postfix + "/online-installer.exe", root_dir + "/online-installer.exe")
         base.copy_file(git_dir + "/desktop-apps/win-linux/" + apps_postfix + "/DesktopEditors.exe", root_dir + "/editors.exe")
         base.copy_file(git_dir + "/desktop-apps/win-linux/res/icons/desktopeditors.ico", root_dir + "/app.ico")

scripts/develop/dependence.py

@@ -190,7 +190,7 @@ def check_nodejs():
   nodejs_cur_version_major = int(nodejs_version.split('.')[0][1:])
   nodejs_cur_version_minor = int(nodejs_version.split('.')[1])
   print('Installed Node.js version: ' + nodejs_version[1:])
-  nodejs_min_version = '22'
+  nodejs_min_version = '18'
   nodejs_min_version_minor  = 0
   major_minor_min_version = nodejs_min_version.split('.')
   nodejs_min_version_major = int(major_minor_min_version[0])
@@ -214,7 +214,7 @@ def check_nodejs():
       isNeedReinstall = True
 
   if (True == isNeedReinstall):
-    print('Installed Node.js version must be 22 or higher.')
+    print('Installed Node.js version must be 18 or higher.')
     if (host_platform == 'windows'):
       dependence.append_uninstall('Node.js')
       dependence.append_install('Node.js')
@@ -950,7 +950,7 @@ def install_postgresql():
   return code
 
 def install_nodejs():
-  os.system('curl -sSL https://deb.nodesource.com/setup_22.x | sudo -E bash -')
+  os.system('curl -sSL https://deb.nodesource.com/setup_18.x | sudo -E bash -')
   base.print_info("Install node.js...")
   install_command = 'yes | sudo apt install nodejs'
   print(install_command)
@@ -959,7 +959,7 @@ def install_nodejs():
 downloads_list = {
   'Windows': {
     'Git': 'https://github.com/git-for-windows/git/releases/download/v2.29.0.windows.1/Git-2.29.0-64-bit.exe',
-    'Node.js': 'https://nodejs.org/dist/v22.13.1/node-v22.13.1-x64.msi',
+    'Node.js': 'https://nodejs.org/dist/v18.17.1/node-v18.17.1-x64.msi',
     'Java': 'https://aka.ms/download-jdk/microsoft-jdk-11.0.18-windows-x64.msi',
     'RabbitMQ': 'https://github.com/rabbitmq/rabbitmq-server/releases/download/v3.8.9/rabbitmq-server-3.8.9.exe',
     'Erlang': 'http://erlang.org/download/otp_win64_23.1.exe',

scripts/package_desktop.py

@@ -178,7 +178,7 @@ def make_advinst():
   return
 
 def make_online():
-  if not common.platform in ["windows_x64", "windows_x86"]:
+  if not common.platform in ["windows_x86_xp"]:
     return
   online_file = "%s-%s-%s.exe" % ("OnlineInstaller", package_version, suffix)
   ret = utils.is_file(online_file)

scripts/sdkjs_common/jsdoc/generate_docs_md.py

@@ -168,7 +168,7 @@ def generate_data_types_markdown(types, enumerations, classes, root='../../'):
 
 def generate_class_markdown(class_name, methods, properties, enumerations, classes):
     content = f"# {class_name}\n\nRepresents the {class_name} class.\n\n"
-    content += generate_properties_markdown(properties, enumerations, classes)
+    content += generate_properties_markdown(properties, enumerations, classes, '../')
 
     content += "## Methods\n\n"
     for method in methods:
@@ -191,7 +191,7 @@ def generate_method_markdown(method, enumerations, classes):
     
     # Syntax
     param_list = ', '.join([param['name'] for param in params]) if params else ''
-    content += f"## Syntax\n\n```javascript\nexpression.{method_name}({param_list});\n```\n\n"
+    content += f"## Syntax\n\nexpression.{method_name}({param_list});\n\n"
     if memberof:
         content += f"`expression` - A variable that represents a [{memberof}](../{memberof}.md) class.\n\n"
 
@@ -235,7 +235,7 @@ def generate_method_markdown(method, enumerations, classes):
 
     return escape_text_outside_code_blocks(content)
 
-def generate_properties_markdown(properties, enumerations, classes, root='../'):
+def generate_properties_markdown(properties, enumerations, classes, root='../../'):
     if properties is None:
         return ''
     
@@ -373,9 +373,7 @@ def generate(output_dir):
     generate_docs_json.generate(output_dir + 'tmp_json', md=True)
     for editor_name in editors:
         input_file = os.path.join(output_dir + 'tmp_json', editor_name + ".json")
-
-        shutil.rmtree(output_dir + f'/{editor_name.title()}')
-        os.makedirs(output_dir + f'/{editor_name.title()}')
+        os.makedirs(output_dir + f'/{editor_name.title()}', exist_ok=True)
 
         data = load_json(input_file)
         process_doclets(data, output_dir, editor_name.title())

scripts/sdkjs_common/jsdoc/generate_docs_plugins_md.py

@@ -168,7 +168,7 @@ def generate_data_types_markdown(types, enumerations, classes, root='../../'):
 
 def generate_class_markdown(class_name, methods, properties, enumerations, classes):
     content = f"# {class_name}\n\nRepresents the {class_name} class.\n\n"
-    content += generate_properties_markdown(properties, enumerations, classes)
+    content += generate_properties_markdown(properties, enumerations, classes, '../')
 
     content += "## Methods\n\n"
     for method in methods:
@@ -198,7 +198,7 @@ def generate_method_markdown(method, enumerations, classes):
     
     # Syntax
     param_list = ', '.join([param['name'] for param in params]) if params else ''
-    content += f"## Syntax\n\n```javascript\nexpression.{method_name}({param_list});\n```\n\n"
+    content += f"## Syntax\n\nexpression.{method_name}({param_list});\n\n"
     if memberof:
         content += f"`expression` - A variable that represents a [{memberof}](../{memberof}.md) class.\n\n"
 
@@ -256,7 +256,7 @@ def generate_method_markdown(method, enumerations, classes):
 
     return escape_text_outside_code_blocks(content)
 
-def generate_properties_markdown(properties, enumerations, classes, root='../'):
+def generate_properties_markdown(properties, enumerations, classes, root='../../'):
     if properties is None:
         return ''
     
@@ -309,9 +309,9 @@ def generate_enumeration_markdown(enumeration, enumerations, classes):
             for raw_t in enumeration['type']['names']:
                 # Attempt linking
                 if any(enum['name'] == raw_t for enum in enumerations):
-                    content += f"- [{raw_t}](../Enumeration/{raw_t}.md)\n"
+                    content += f"- [{raw_t}](../../Enumeration/{raw_t}.md)\n"
                 elif raw_t in classes:
-                    content += f"- [{raw_t}](../{raw_t}/{raw_t}.md)\n"
+                    content += f"- [{raw_t}](../../{raw_t}/{raw_t}.md)\n"
                 else:
                     content += f"- {raw_t}\n"
 
@@ -425,20 +425,15 @@ def process_doclets(data, output_dir, editor_name):
 def generate(output_dir):
     print('Generating Markdown documentation...')
     
-    if output_dir[-1] == '/':
-        output_dir = output_dir[:-1]
-    
-    generate_docs_plugins_json.generate(output_dir + '/tmp_json', md=True)
+    generate_docs_plugins_json.generate(output_dir + 'tmp_json', md=True)
     for editor_name in editors:
-        input_file = os.path.join(output_dir + '/tmp_json', editor_name + ".json")
-
-        shutil.rmtree(output_dir + f'/{editor_name.title()}', ignore_errors=True)
-        os.makedirs(output_dir + f'/{editor_name.title()}')
+        input_file = os.path.join(output_dir + 'tmp_json', editor_name + ".json")
+        os.makedirs(output_dir + f'/{editor_name.title()}', exist_ok=True)
 
         data = load_json(input_file)
         process_doclets(data, output_dir, editor_name.title())
     
-    shutil.rmtree(output_dir + '/tmp_json')
+    shutil.rmtree(output_dir + 'tmp_json')
     print('Done')
 
 if __name__ == "__main__":

scripts/sdkjs_common/jsdoc/generate_jsonl_dataset.py

@@ -0,0 +1,248 @@
+import os
+import json
+import re
+import shutil
+import argparse
+import generate_docs_json
+from datetime import datetime
+
+# Configuration files
+editors = [
+    "word",
+    "cell",
+    "slide",
+    "forms"
+]
+
+root = '../../../..'
+missing_examples = []
+
+def load_json(file_path):
+    with open(file_path, 'r', encoding='utf-8') as f:
+        return json.load(f)
+
+def read_file_content(file_path):
+    try:
+        with open(file_path, encoding='utf-8') as f:
+            return f.read()
+    except Exception as e:
+        missing_examples.append(file_path)
+        # print(f"Failed to open file {file_path}: {e}")
+        return ""
+
+def extract_js_comments_as_text(text):
+    # Extract single-line comments (after //)
+    single_line_comments = re.findall(r'^\s*//(.*)$', text, flags=re.MULTILINE)
+    # Extract multi-line comments (between /* and */)
+    multi_line_comments = re.findall(r'/\*(.*?)\*/', text, flags=re.DOTALL)
+    # Combine all found comments into a single list
+    all_comments = single_line_comments + multi_line_comments
+    # Join comments into a single text, separated by a space
+    return " ".join(comment.strip() for comment in all_comments if comment.strip())
+
+def extract_examples_blocks(content: str):
+    blocks = []
+    current_block = {"comments": [], "code": []}
+    in_comment_section = True  # Collect comments until code appears
+    current_comment_group = []  # Accumulate lines of the current comment
+
+    for line in content.splitlines():
+        stripped = line.strip()
+        if not stripped:
+            # Empty line
+            if in_comment_section and current_comment_group:
+                # Finish the current comment group
+                comment_text = " ".join(current_comment_group)
+                current_block["comments"].append(comment_text)
+                current_comment_group = []
+            elif not in_comment_section:
+                # Empty line in the code – keep it as is
+                current_block["code"].append(line)
+            continue
+
+        if stripped.startswith("//"):
+            if in_comment_section:
+                # Remove comment marker and extra spaces
+                current_comment_group.append(extract_js_comments_as_text(stripped))
+            else:
+                # Comment after code starts – finish the current block and start a new one
+                blocks.append({
+                    "comments": current_block["comments"],
+                    "code": "\n".join(current_block["code"]).rstrip()
+                })
+                current_block = {"comments": [], "code": []}
+                in_comment_section = True
+                # Start a new comment group with the current line
+                current_comment_group = [stripped[2:].strip()]
+        else:
+            # Code line
+            if in_comment_section:
+                if current_comment_group:
+                    comment_text = " ".join(current_comment_group)
+                    current_block["comments"].append(comment_text)
+                    current_comment_group = []
+                in_comment_section = False
+            current_block["code"].append(line)
+
+    # Finalize any remaining comment group
+    if in_comment_section and current_comment_group:
+        comment_text = " ".join(current_comment_group)
+        current_block["comments"].append(comment_text)
+    # Save the last block if it's not empty
+    if current_block["comments"] or current_block["code"]:
+        blocks.append({
+            "comments": current_block["comments"],
+            "code": "\n".join(current_block["code"]).rstrip()
+        })
+
+    return blocks
+
+def extract_examples_blocks_temp(content: str):
+    lines = content.splitlines()
+    comment_blocks = []
+    current_group = []
+    first_code_index = None
+
+    for i, line in enumerate(lines):
+        stripped = line.strip()
+        if not stripped:
+            if current_group:
+                comment_blocks.append(" ".join(current_group))
+                current_group = []
+            continue
+        if stripped.startswith("//"):
+            current_group.append(stripped[2:].strip())
+        else:
+            if current_group:
+                comment_blocks.append(" ".join(current_group))
+                current_group = []
+            first_code_index = i
+            break
+
+    code_part = ""
+    if first_code_index is not None:
+        code_part = "\n".join(lines[first_code_index:]).rstrip()
+
+    return [{"comments": comment_blocks, "code": code_part}]
+
+def create_entry(system_message, user_message, assistant_message, model):
+    entry = {
+        "created_at": datetime.now().isoformat(" "),
+        "messages": [
+            {"role": "system", "content": system_message},
+            {"role": "user", "content": user_message},
+            {"role": "assistant", "content": assistant_message}
+        ],
+        "recommended": False,
+        "upvoted": True
+    }
+
+    if model is not "":
+        entry["model"] = model
+
+    return entry 
+
+def process_doclets(doclets, output_entries, editor_name, model):
+    for doclet in doclets:
+        kind = doclet.get("kind", "").lower()
+        see = doclet.get("see", [])
+        
+        # The "see" field must always be present
+        if not see:
+            continue
+        
+        # Processing based on the "kind" value
+        if kind == "function":
+            method_name = doclet.get("name", "")
+            memberof = doclet.get("memberof", "")
+            # Functions must have both "name" (method_name) and "memberof" fields filled
+            if not (method_name and memberof):
+                continue
+            system_message = (
+                f"You act as an API expert for Onlyoffice {editor_name.title()} editor. "
+                f"This task is an example for the function {method_name} in the class {memberof}."
+            )
+            default_user_message = f"How do I use the method {method_name} of {memberof} class?"
+            
+        elif kind == "class":
+            class_name = doclet.get("name", "")
+            system_message = (
+                f"You act as an API expert for Onlyoffice {editor_name.title()} editor. "
+                f"This task is an example for the class {class_name}."
+            )
+            default_user_message = f"How do I instantiate or work with the class {class_name}?"
+            
+        elif kind == "typedef":
+            typedef_name = doclet.get("name", "")
+            system_message = (
+                f"You act as an API expert for Onlyoffice {editor_name.title()} editor. "
+                f"This task is an example for the typedef {typedef_name}"
+            )
+            default_user_message = f"How do I use the typedef {typedef_name}?"
+            
+        else:
+            continue
+        
+        # Read the content of the first file listed in the "see" field
+        content = read_file_content(f'{root}/{see[0]}')
+        if content == "":
+            continue
+        
+        # now use only first block cause there is bad comments in examples
+        blocks = extract_examples_blocks_temp(content)
+        
+        for block in blocks:
+            assistant_message = block['code']
+
+            # default entry
+            output_entries.append(create_entry(system_message, default_user_message, assistant_message, model))
+
+            # If the file content contains comments, create a separate entry for each one
+            for comment in block['comments']:
+                output_entries.append(create_entry(system_message, comment, assistant_message, model))
+            
+def generate(output_dir, model):
+    print('Generating documentation JSONL dataset...')
+    
+    shutil.rmtree(output_dir, ignore_errors=True)
+    os.makedirs(output_dir)
+
+    generate_docs_json.generate(f'{output_dir}/tmp_json')
+    
+    output_entries = []
+    output_filename = "dataset.jsonl"
+
+    for editor_name in editors:
+        input_file = os.path.join(f'{output_dir}/tmp_json', editor_name + ".json")
+        doclets = load_json(input_file)
+        process_doclets(doclets, output_entries, editor_name, model)
+    
+    with open(f'{output_dir}/{output_filename}', "w", encoding="utf-8") as out_file:
+        for entry in output_entries:
+            out_file.write(json.dumps(entry, ensure_ascii=False) + "\n")
+
+    shutil.rmtree(f'{output_dir}/tmp_json')
+    print('Done')
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Generate documentation JSONL dataset")
+    parser.add_argument(
+        "destination", 
+        type=str, 
+        help="Destination directory for the generated documentation",
+        nargs='?',  # Indicates the argument is optional
+        default="../../../../office-js-api/dataset"  # Default value
+    )
+    parser.add_argument(
+        "model", 
+        type=str, 
+        help="Type of model",
+        nargs='?',  # Indicates the argument is optional
+        default=""  # Default value
+    )
+    args = parser.parse_args()
+
+    generate(args.destination, args.model)
+    print("START_MISSING_EXAMPLES")
+    print(",".join(missing_examples))
+    print("END_MISSING_EXAMPLES")

sln.json

@@ -93,7 +93,7 @@
     
     "[win]desktop-apps/win-linux/extras/projicons/ProjIcons.pro",
     "[win,!win_xp]desktop-apps/win-linux/extras/update-daemon/UpdateDaemon.pro",
-    "[win,!win_xp]desktop-apps/win-linux/extras/online-installer/OnlineInstaller.pro"
+    "[win_xp]desktop-apps/win-linux/extras/online-installer/OnlineInstaller.pro"
   ],
 
   "mobile" : [

tools/linux/deps.py

@@ -67,7 +67,7 @@ def install_deps():
     print("OK")
     base.cmd("sudo", ["apt-get", "-y", "install", "npm", "yarn"], True)
   base.cmd("sudo", ["npm", "install", "-g", "grunt-cli"])
-  base.cmd("sudo", ["npm", "install", "-g", "@yao-pkg/pkg"])
+  base.cmd("sudo", ["npm", "install", "-g", "pkg"])
 
   # java
   java_error = base.cmd("sudo", ["apt-get", "-y", "install", "openjdk-11-jdk"], True)