CCDirectLink - User contributions [en]

CCLoader

2024-09-06T23:57:19Z

Streetclaw: Image resize

'''CCLoader''' is the de facto modloader for CrossCode and obviously a prerequisite for playing the CrossCode with mods. Really, it is the only actively developed modloader intended for use by both mod users and mod developers (RIP [https://github.com/20kdc/decrossfuscator/blob/master/lib/rapture.js Rapture] + [https://github.com/20kdc/decrossfuscator/tree/master/mods pre-1.1.0 mods], [[Dorito]] and [[CCInjector]]).

= Installation =

There are three ways to perform CCLoader installation, they are both described in this document. But before we continue:

== '''VERY IMPORTANT NOTE:''' Don't use the green "clone or download" button! ==

[[File:Clone-or-download.png|class=block-img]]

This button downloads the source code, not the compiled files! In the case of CCLoader you can't just download the source code and run it because CCLoader is not written in JavaScript! While this doesn't apply to all CrossCode mods out there as most of them are written in plain JS and as such don't need to be compiled, '''you should get used to looking at the "Releases" page first before trying to download the source code'''. In the new redesigned GitHub UI the link to it became more apparent:

[[File:Github-project-frontpage-releases.png|700px]]

== Method 1: Quick-installation archive ==

This method is recommended for most users (at least right now because the mod manager is not stable enough for a public release and has a few critical bugs) and will very likely remain the primary installation method because of its simplicity.

# Obviously, '''first of all you have to locate the [[Locations of CrossCode files#Game files folder|CrossCode game files folder]].'''
# Go to the [https://github.com/CCDirectLink/CCLoader/releases/latest latest release page] of CCLoader.
# In the "Assets" list at the bottom of the release click the link which says '''Source code (zip)''' (a <code>tar.gz</code> download also exist for GNU/Linux and macOS users). This will download a quick installation archive.
# Extract this archive somewhere:<br>[[File:Extract-ccloader-quick-install.png|class=block-img]]
# Copy the files inside the archive directly into the game folder, like this:<br>[[File:Ccloader-quick-install.png|700px]]<br>The only file you'll have to overwrite in a clean CrossCode installation is the <code>package.json</code>:<br>[[File:Ccloader-quick-install-overwrite-package-json.png|class=block-img]]
# You've now successfully installed CCLoader! The end result should look like (notice the new <code>ccloader</code> folder):<br>[[File:Ccloader-installation-end-result.png|700px]]
# Mods can be installed into the <code>mods</code> folder located inside <code>assets</code>, for more information on that see the [[Installing mods|relevant guide]].

=== Bonus for Linux users ===

On Linux this entire process can be performed with two commands:

<syntaxhighlight lang="bash">
cd /path/to/CrossCode
# Replace the version in the URL here with the latest one:
curl --location --fail 'https://github.com/CCDirectLink/CCLoader/archive/refs/tags/v2.20.2/v2.10.1.zip' \
| tar --extract --gzip --verbose --file -
</syntaxhighlight>

=== Verifying a successful CCLoader installation ===

Upon launching the game you'll see the CCLoader version in the bottom right corner of the title screen and at the top of the pause screen (where the game version is) if CCLoader was installed correctly. You'll also be able to see the following tab in the options menu:

[[File:Ccloader-mod-settings-menu.png|700px]]

It will obviously be empty if you haven't [[Installing mods|installed any mods]].

== Method 2: Using the automatic installer ==

See https://github.com/CCDirectLink/ccloader-installer. It may be broken though.

[[Category:Modloaders]]

Category:Pages with script errors

2024-09-06T23:48:19Z

Streetclaw: Created blank page

CrossCode Modding Tutorial

2024-09-06T23:46:45Z

Streetclaw: Update deprecated tags

This page contains the steps on how to create your very first CrossCode mod. (header WIP, ask 2767mr)

= Installing CCLoader =

⚠ '''Due to DRM it is not possible to mod Xbox Game Pass or Microsoft Store versions of the game.'''

See [[CCLoader#Installation]]

= Installing NW.js =

== Requirements ==

* [[Locations_of_CrossCode_files#Game_files_folder|CC installation folder]]
* [https://nwjs.io NW.js SDK zip]

⚠ '''The game uses an outdated version of NW.js, so you might want to use version <code>0.35.5</code> to avoid accidentally using features not yet available in CrossCode.'''

== Steps ==

# Open the nwjs-sdk zip
# Open the folder so you can see the <code>nw.exe</code> file

[[File:nwjsRoot.png|class=block-img]]

# <li value=3>Extract/drag all files into the [[Locations_of_CrossCode_files#Game_files_folder|CC installation folder]] and replace existing files when prompted.</li>
# Delete <code>CrossCode.exe</code>
# Rename <code>nw.exe</code> to <code>CrossCode.exe</code>
# Open the game
# Press F12 to open the Chrome DevTools
# Click the <code>Console</code> tab
# In the top bar, click <code>top</code>
# Choose the second entry in the dropdown list
# You can now enter commands into the console

= Making a mod =

== Requirements ==

* [[CCLoader#Installation|Installing CCLoader]]
* [[Locations_of_CrossCode_files#Game_files_folder|CC installation folder]]

== Steps ==

# Open the [[Locations_of_CrossCode_files#Game_files_folder|CC installation folder]]
# Open <code>assets</code> -> <code>mods</code>
# Create a new folder for your mod. In this example, we are going to use <code>myMod</code>
# Create a new file called <code>package.json</code>

This file is used to tell CCLoader how to load your mod. It contains the internal name (<code>name</code>), the in-game displayed name (<code>ccmodHumanName</code>), the version number (<code>version</code>) and dependencies (<code>ccmodDependencies</code>). Only <code>name</code> and <code>version</code> are required.

=== Example <code>package.json</code> ===

<syntaxhighlight lang="json" line="line">
{
"name": "my-mod",
"ccmodHumanName": "My Mod",
"version": "1.0.0"
}
</syntaxhighlight>

# <li value=5>Find a file to modify</li>

In this example we will do a simple palette swap of Lea. You can find her sprites in <code>assets/media/entity/player/move.png</code>

# <li value=6>Copy the file to your mod</li>

In order for CCLoader to pick up the file from the mod it needs to be inside the mod folder with the same name as the original. This means that <code>assets/media/entity/player/move.png</code> turns into <code>assets/mods/myMod/assets/media/entity/player/move.png</code>.

⚠ '''Do not publish original CrossCode files in your mod.'''

# <li value=7>Edit the file</li>

In this example I am using Paint.NET to swap Lea's red clothes for green ones:

[[File:leaRecolor.png|class=block-img]]

# <li value=8>Restart the game and test your mod</li>

[[File:leaRecolored.png|class=block-img]]

= Editing JSON =

Often it is not enough to just edit png files to make mods. Changing sizes, making new entities or maps require one to edit or create new JSON files. This guide shows you how to work with JSON files in your mod.

== Requirements ==

* [[CrossCode Modding Tutorial#Making a mod|Making a mod]]

== New JSON files ==

Adding new JSON files does not require any special attention. Simply put the file into the correct folder and CCLoader will pick it up automatically.

== Existing JSON files ==

Editing existing JSON files is problematic in a few cases. Now only are these files pretty big but there are also a lot of instances where multiple mods want to modify the same file. In that case simply replacing the entire file doesn’t work.

Instead you can use a mechanism called patches. These are files that only record the changes made to the original file, allowing multiple mods to apply patches to the same file. They work similar to file replacements as they require you to use the same name as the original file. The difference is that they append a <code>.patch</code> to the filename and use special sytanx exmplained in more detail on [[Patching]].

In order to work with JSON files it is recommend to beautify them before using them. You can use [https://beautifier.io/ beautifier.io] to do that for you.

In this example we will make a patch that will increase the damage Lea does. This information can be found in <code>assets/data/players/lea.json</code>. Once beautified one can easily see the value we want to modify.

<syntaxhighlight lang="json" line="line">
{
"character": "main.lea",
"sheet": "player",
"headIdx": 0,
"class": "SPHEROMANCER",
"stats": {
"hp": {
"base": 200,
"increase": 2000,
"variance": 0.1
},
"attack": {
"base": 20,
"increase": 200,
"variance": 0.9
},
...
</syntaxhighlight>

Now we want to somehow change <code>stats.attack.base</code> to <code>200</code>. For that we first create a patch file <code>assets/mods/myMod/assets/data/players/lea.json.patch</code>

🚀 '''Tip: Most editors will not recognize these files as JSON by default. Almost all popular editors include a feature to manually set which type of file you are currently editing.'''

First you can begin the file with <code>[]</code> to signal that this file is using the “Patch Step” format:

<syntaxhighlight lang="json" line="line">
[

]
</syntaxhighlight>

Next we insert a step that navigates into the <code>attack</code> object:

<syntaxhighlight lang="json" line="line">
{
"type": "ENTER",
"index": ["stats", "attack"]
}
</syntaxhighlight>

Now we can overwride a value:

<syntaxhighlight lang="json" line="line">
{
"type": "SET_KEY",
"index": "base",
"content": 200
}
</syntaxhighlight>

At the end, we navigate back to the root of the document. In this case it is not required but will make future additions a lot easier.

<syntaxhighlight lang="json" line="line">
{
"type": "EXIT",
"count": 2
}
</syntaxhighlight>

At the end we end up with this <code>lea.json.patch</code> file:

<syntaxhighlight lang="json" line="line">
[{
"type": "ENTER",
"index": ["stats", "attack"]
}, {
"type": "SET_KEY",
"index": "base",
"content": 200
}, {
"type": "EXIT",
"count": 2
}]
</syntaxhighlight>

= Making a JavaScript mod =

Although the game provides a very powerful JSON scripting system it is sometimes required to add new puzzle elements or edit internal workings of existing ones. For this one needs javascript mods.

== Requirements ==

* [[CrossCode Modding Tutorial#Making a mod|Making a mod]]

== Entry points ==

In order to load a JavaScript file, there needs to be an entry in the <code>package.json</code> of the mod. There are multiple possible values here that reference different points in time at which a mod is loaded. Furthermore there is an entry called <code>plugin</code> which combines all these entry points.

For example, if we want to double all gained CP points we need to add a script:

<syntaxhighlight lang="json" line="line">
{
"name": "my-mod",
"ccmodHumanName": "My Mod",
"version": "1.0.0",
"plugin": "plugin.js"
}
</syntaxhighlight>
{|
!width="100%"| ⚠ If you use entry points other than <code>plugin</code> you should always set <code>"module": true</code> as well.
|}

== Mod loading stages ==

=== Prestart ===

This is the entry point you usually want to use. At this point, most of the game code is loaded but almost none of it executed yet. This makes it the perfect chance to change how the internals work.

=== Preload ===

At this point none of the game has been loaded yet. This means that while nothing has loaded yet but one can use this to set up libraries or use some JavaScript black magic.

=== Postload ===

Here some of the game code has been loaded, however pretty much nothing has been executed yet. Specifically, none of the resources have been been loaded yet, making it possible to intercept and work with them.

=== Main ===

This stage, which has been called “main” for legacy reasons, executes code as soon as the title menu start playing. This allows mods to use code that may have not been executed yet in the prestart stage, though it should be avoided is easily possible.

== Plugin ==

While using loading stages directly in the <code>package.json</code> directly executes the code in a script the plugin combines multiple stages at once. Every plugin defines an exported JavaScript class that is used to execute the code.

Since we defined the file as <code>plugin.js</code> above we create a new file <code>assets/mods/myMod/plugin.js</code>:

<syntaxhighlight lang="js" line="line">
export default class MyMod {
prestart() {
//Prestart code will go in here.
}
}
</syntaxhighlight>
The advantage of using plugins over direct stages is that the constructor of the plugin receives an object as argument which can be used to find out which folder the current mod is stored in.

🚀 '''Tip: A plugin can also be used to write async code in a loading stage, blocking all other mods from loading until it has finished.'''

Now that we can execute code in the prestart stage, we need to find out how to double the CP points. If we look into the <code>assets/js/game.compiled.js</code> file we can find out that there is a class called <code>sc.PlayerModel</code> which contains a function

<syntaxhighlight lang="ts">public addSkillPoints(points: number, element: number, all: boolean, extra: boolean): void</syntaxhighlight>
We now want to manipulate <code>addSkillPoints</code> so that <code>points</code> are doubled. For that we can use the <code>inject</code> function. This is a function that exists on all classes that allows you to add and overwrite existing functions. Furthermore, inside that function you can use <code>this.parent(...)</code> to call the original functon.

We can use this to make a mod that doubles all CP:

<syntaxhighlight lang="js" line="line">
export default class MyMod {
prestart() {
sc.PlayerModel.inject({
addSkillPoints(points, element, all, extra) {
this.parent(points*2, element, all, extra);
}
});
}
}
</syntaxhighlight>

This example mod can be found on GitHub.<ref>https://github.com/CCDirectLink/CrossCode-Modding-Tutorial/tree/master/example</ref>

= Share your mod =

== Requirements ==

* [[CrossCode Modding Tutorial#Making a mod|Making a mod]]

== Steps ==

# Open your mod folder that contains the <code>package.json</code> file
# Select all files/folders needed for the mod
# Create a zip archive from these files. On Windows you can do this using right click > send to > zip-archived folder

You can already share this file

<ol start="4" style="list-style-type: decimal;">
<li>Rename the .zip file to .ccmod</li></ol>

This allows other users to simply drag the file into the mods folder and not have to worry about extracting it

== Publish on the official list ==

Since the process of approving a mod for the official list is a bit complicated (and is likely to change in the future) the best way is to:
* Publish your source code on [https://github.com/ GitHub]
* Make sure you have a correct version number
* Create a [https://docs.github.com/en/free-pro-team@latest/github/administering-a-repository/managing-releases-in-a-repository Github Release] - you can upload your .ccmod file there
* Message (an admin) on the [https://discord.gg/TFs6n5v CrossCode Modding Discord] to add your mod to the list

== References ==

<references />

[[Category:Modding guides]]

Installing mods

2024-09-06T23:33:58Z

Streetclaw: /* Downloading releases */ Resize image

This guide describes the most common way of installation of perfectly regular CrossCode mods. Granted, not every mod is equal, some may require additional setup before or after installation, but that must be described in mod's README document. If not - well, this is most likely the mod author's problem. Note that you don't have to read this guide each time you download a new mod as this page is intended for absolute beginners.

=== Short note about upgrading mods ===

You '''can''' perform mod upgrades by performing the steps described in this guide, but replacing all previous files when unpacking the downloaded mod. However, '''this is not recommended''' (by me at least) - instead you should first delete the folder with the previous version of the mod you are upgrading and only then unpack the new version, just in case.

== Step 1. Install [[CCLoader]] ==

CCLoader (aka the '''C'''ross'''C'''ode mod'''loader''') is required for most mods nowadays to work. Well, it is possible to <s>ab</s>use the DLC/extension system for creating simple asset swaps, but these are its limits - it's ''definitely'' not designed for full-fledged modding. CCLoader also provides various tooling for mod authors for selectively patching game content, so that mod authors can put just the changed bits of game files in their mods instead of copying them entirely. The guide about CCLoader installation can be found [[CCLoader#Installation|here]].

== Step 2. Get the mod files ==

Most mods are distributed as zip archives. There are two ways to obtain those:

=== Downloading releases ===

''See also [[CCLoader#VERY IMPORTANT NOTE: Don't use the green "clone or download" button!|this section]] of the CCLoader installation guide''

Unless explicitly stated otherwise in the mod's README, '''when actually downloading mods you should always check first for released versions''', or "releases" for short. Most mod authors use GitHub for storing source code and distributing releases where you can access the page with changelogs and downloads through these links:

[[File:Github-mod-releases.png|900px]]

Pressing on the version marked as "latest" will take you to, unsurprisingly, the page of the latest release, pressing on the <code>Releases (N)</code> or <code>+N releases</code> links at the top and bottom (where <code>N</code> is some number) will take you to a list of all available versions. Mods also often include the following badge in their README which takes you directly to downloads:

[https://raw.githubusercontent.com/CCDirectLink/organization/master/assets/badges/releases@2x.png https://raw.githubusercontent.com/CCDirectLink/organization/master/assets/badges/releases@2x.png]

On the release page you'll see the section named "Assets". It always includes at least two entries: "Source code (zip)" and "Source code (tar.gz)". If only links for downloading source code are present - don't worry, you can use those to install the mod. Just download whichever archive format you prefer. Otherwise mod authors upload at least zip archives on the downloads page, usually the file name of those includes the mod ID and version.

=== Downloading source code ===

Most of the time mod authors publish the releases properly, but when the "releases" page is empty or the link is hidden it can mean one of three things:

# The project is dead.
# The mod is work-in-progress project, or WIP for short. Such mods usually don't have a proper README file. In this case you should contact the author to ask if the mod is usable. You can also potentially help with the development - sometimes mods may need testers.
# The author was just lazy to publish releases properly. Most mods don't require compilation or preprocessing of assets or scripts to be loaded into the game and work, so in such cases you can try to download the mod's source code. On GitHub this can be done by pressing the green "code" button with a download icon to the left, and then pressing "download ZIP" in the opened popup:<br>[[File:Mod-download-source-code.png|class=block-img]]

'''Beware, however, that sometimes the source code of mods is structured in a weird way''', mostly in mods made by ac2pic aka Emileyah, so sometimes you can't just put files of the downloaded archive into your mods folder and call it a day. As a rule of thumb, a folder which contains a file named <code>ccmod.json</code> is most likely a mod. In the case of ac2pic's mods, the mod is usually located in a subfolder named similarly to the mod itself.

== Step 3. Unpack the downloaded mod into your mods folder ==

The title of this step is a bit misleading, because depending on the type of mod you downloaded, you may not even have to extract it.

To locate your mods folder you first need to find the [[Locations of CrossCode files#Game files folder|CrossCode game files folder]], then go to <code>assets</code>, then <code>mods</code>. If the folder <code>mods</code> doesn't exist - create it.

=== Is your mod a <code>.ccmod</code> file? ===

Worry not! All you have to do is move the file into the <code>mods</code> folder.

=== Is your mod a <code>.zip</code> file? ===

Unpack the mod folder contained in the archive you downloaded there. Be sure to put the mod folder in <code>mods</code>, not the files inside because '''each mod lives in its own separate folder'''! You can also ensure that the folder you unpacked contains a file named <code>ccmod.json</code>.

[[File:Mods-dir-structure-separate-folders.png]]

'''NOTE:''' these screenshots are a bit outdated (TODO update, include multiple mods to better demonstrate the idea), for example because they doesn't contain <code>ccmod.json</code>, but I hope you get the correct idea.

== Step 4. PROFIT!!! ==

This basically concludes installation of perfectly regular mods.

== Common mod installation problems ==

=== "Problem with requirements of mod" errors are printed and the mod isn't loaded ===

Some mods work only on certain versions of CrossCode or CCLoader and some mods require other mods to function (so-called libraries). If these requirements of a given mod aren't met when the game is loaded, the modloader will simply skip this mod and proceed to start the game without it.

{| class="wikitable"
!width="25%"| Requirement problem
!width="75%"| Explanation
|-
| <code>mod 'xyz' is not installed</code>
| The mod <code>xyz</code> is a so-called "dependency" of the mod you installed and you should install it as well. Usually dependencies are listed in the mod's README.
|-
| <code>mod 'xyz' is disabled</code>
| Unsurprisingly, you have to enable the mod <code>xyz</code> to get the installed mod working.
|-
| <code>mod 'xyz' is not loaded</code>
| If there is a problem in the chain of dependencies, then all mods in that chain aren't loaded. See the error which caused <code>xyz</code> to not be loaded.
|-
| <code>version of xyz is not in range abc</code>
| The installed mod is compatible with a specific range of versions of <code>xyz</code>, try downgrading or upgrading <code>xyz</code>.
|-
| <code>mod 'xyz' doesn't have a version</code>
| The developer of the mod you are installing likely made a mistake or you downloaded a very old development version of <code>xyz</code>.
|}

[[Category:Guides for mod users]]

MediaWiki:Cc-discord-description

2024-08-01T15:08:01Z

Streetclaw: Update description

Radical Fish Discord

MediaWiki:Sidebar

2024-08-01T14:55:10Z

Streetclaw: Add CC Discord to navigation

MediaWiki:Cc-discord-description

2024-08-01T14:54:28Z

Streetclaw: CC Discord description

CrossCode Discord

MediaWiki:Cc-discord-url

2024-08-01T14:53:33Z

Streetclaw: Add CC Discord-URL

https://discord.gg/radicalfish

MediaWiki:Discord-description

2024-08-01T14:17:04Z

Streetclaw: Refine description

Modding Discord

File:Ui note error.svg

2023-05-25T19:04:12Z

Streetclaw:

== Licensing (MIT) ==

Copyright © 2011–2018 [https://phabricator.wikimedia.org/diffusion/GOJU/browse/master/AUTHORS.txt OOjs UI Team and other contributors]

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

The Software is provided "as is", without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the Software or the use or other dealings in the Software.

File:Ui note warn.svg

2023-05-25T19:02:39Z

Streetclaw:

File:Ui note reminder.svg

2023-05-25T19:02:02Z

Streetclaw:

File:Ui note info.svg

2023-05-25T18:59:46Z

Streetclaw: Licensing added

File:Ui note reminder.svg

2023-05-25T18:26:19Z

Streetclaw:

File:Ui note info.svg

2023-05-25T18:21:03Z

Streetclaw:

MediaWiki:Sidebar

2023-02-03T16:51:46Z

Streetclaw: Twitter url removed (no account)

Module:List/doc

2020-08-31T22:44:25Z

Streetclaw:

List template. Based on [https://www.mediawiki.org/wiki/Module:List MediaWiki List Module]

== About ==
Creates a list in an specified format.

== Parameter ==
{{TemplateData|
{{TemplateData/entry|name=listType|param=1|desc=List type|example=
<pre>{{#invoke:list|bulleted|a|b|c}}</pre>
{{#invoke:list|bulleted|a|b|c}}
<pre>{{#invoke:list|unbulleted|a|b|c}}</pre>
{{#invoke:list|unbulleted|a|b|c}}
<pre>{{#invoke:list|horizontal|a|b|c}}</pre>
{{#invoke:list|horizontal|a|b|c}}
<pre>{{#invoke:list|ordered|a|b|c}}</pre>
{{#invoke:list|ordered|a|b|c}}
<pre>{{#invoke:list|horizontal_ordered|a|b|c}}</pre>
{{#invoke:list|horizontal_ordered|a|b|c}}
|def=NULL|type=<nowiki>[ "bulleted" | "unbulleted" | "horizontal" | "ordered" | "horizontal_ordered" ]</nowiki>|status=Required}}
{{TemplateData/entry|name=listEntries|param=2...x|desc=List entries|def=NULL|type=WikiCode|status=Optional}}
{{TemplateData/entry|name=olStart|param=start|desc=Start entry. <pre><ol start=""></pre> [https://developer.mozilla.org/de/docs/Web/HTML/Element/ol#Attribute MDN (ol)]. Requires <code>listType</code> <nowiki>[ "ordered" | "horizontal_ordered" ]</nowiki>|example=
<pre>{{#invoke:list|ordered|a|b|c|start=5}}</pre>
{{#invoke:list|ordered|a|b|c|start=5}}
<pre>{{#invoke:list|ordered|a|b|c|start=-5}}</pre>
{{#invoke:list|ordered|a|b|c|start=-5}}
|def=1|type=SignedNumber|status=Optional}}
{{TemplateData/entry|name=olType|param=type|desc=Ordered list type. <pre><ol type=""></pre> [https://developer.mozilla.org/de/docs/Web/HTML/Element/ol#Attribute MDN (ol)]. Requires <code>listType</code> <nowiki>[ "ordered" | "horizontal_ordered" ]</nowiki>. It's recommended to use <code>style</code>,<code>class</code> or param <code>list_style_type</code> instead|example=
<pre>{{#invoke:list|ordered|a|b|c|type=i}}</pre>
{{#invoke:list|ordered|a|b|c|type=i}}
<pre>{{#invoke:list|ordered|a|b|c|type=a}}</pre>
{{#invoke:list|ordered|a|b|c|type=a}}
|def=1|type=<nowiki>[ "1" | "a" | "A" | "i" | "I" ]</nowiki>|status=Optional}}
{{TemplateData/entry|name=cssType|param=list_style_type|desc=Recommended list style type. Uses the css attribute <code>list-style-type</code>|example=
<pre>{{#invoke:list|ordered|a|b|c|list_style_type=lower-alpha}}</pre>
{{#invoke:list|ordered|a|b|c|list_style_type=lower-alpha}}
<pre>{{#invoke:list|ordered|a|b|c|list_style_type=lower-greek}}</pre>
{{#invoke:list|ordered|a|b|c|list_style_type=lower-greek}}
<pre>{{#invoke:list|ordered|a|b|c|list_style_type=decimal-leading-zero}}</pre>
{{#invoke:list|ordered|a|b|c|list_style_type=decimal-leading-zero}}
|def=NULL|type=[https://developer.mozilla.org/en-US/docs/Web/CSS/list-style-type MDN (list-style-type)]|status=Optional}}
{{TemplateData/entry|name=divClass|param=class|desc=<code>class</code> attribute for the <pre><div>...</div></pre> surrounding the list|def=NULL|type=String|status=Optional}}
{{TemplateData/entry|name=divStyle|param=style|desc=<code>style</code> attribute for the <pre><div>...</div></pre> surrounding the list|def=NULL|type=String|status=Optional}}
{{TemplateData/entry|name=listStyle|param=list_style|desc=<code>style</code> attribute for the list|def=NULL|type=String|status=Optional}}
{{TemplateData/entry|name=itemStyle|param=item_style|desc=<code>style</code> attribute for the list items|def=NULL|type=String|status=Optional}}
{{TemplateData/entry|name=itemXStyle|param=item1_style...itemX_style|desc=<code>style</code> attribute for item x in list|def=NULL|type=String|status=Optional}}
{{TemplateData/entry|name=itemXValue|param=item1_value...itemX_value|desc=<code>value</code> attribute for item x in list|def=NULL|type=String|status=Optional}}
{{TemplateData/entry|name=listIndent|param=indent|desc=Set <code>margin-left</code> for list (<code>intent * 1.6 em</code>)|def=NULL|type=String|status=Optional}}
}}

== Examples ==

{{#invoke:list|bulleted|First item|Second item|Third item|item1_style=background-color:yellow;|item2_style=background-color:silver;color:black;}}

<pre>
{{#invoke:list|bulleted|First item|Second item|Third item|item1_style=background-color:yellow;|item2_style=background-color:silver;color:black;}}
</pre>

Module:List/doc

2020-08-31T22:39:17Z

Streetclaw:

Template for creating a unified parameter format for templates. Based on [https://www.mediawiki.org/wiki/Module:List MediaWiki (Module:List)]

== About ==
Creates a list that displays Template parameter in a unified format.

== Parameter ==
{{TemplateData|
{{TemplateData/entry|name=listType|param=1|desc=List type|example=
<pre>{{#invoke:list|bulleted|a|b|c}}</pre>
{{#invoke:list|bulleted|a|b|c}}
<pre>{{#invoke:list|unbulleted|a|b|c}}</pre>
{{#invoke:list|unbulleted|a|b|c}}
<pre>{{#invoke:list|horizontal|a|b|c}}</pre>
{{#invoke:list|horizontal|a|b|c}}
<pre>{{#invoke:list|ordered|a|b|c}}</pre>
{{#invoke:list|ordered|a|b|c}}
<pre>{{#invoke:list|horizontal_ordered|a|b|c}}</pre>
{{#invoke:list|horizontal_ordered|a|b|c}}
|def=NULL|type=<nowiki>[ "bulleted" | "unbulleted" | "horizontal" | "ordered" | "horizontal_ordered" ]</nowiki>|status=Required}}
{{TemplateData/entry|name=listEntries|param=2...x|desc=List entries|def=NULL|type=WikiCode|status=Optional}}
{{TemplateData/entry|name=olStart|param=start|desc=Start entry. <pre><ol start=""></pre> [https://developer.mozilla.org/de/docs/Web/HTML/Element/ol#Attribute MDN (ol)]. Requires <code>listType</code> <nowiki>[ "ordered" | "horizontal_ordered" ]</nowiki>|example=
<pre>{{#invoke:list|ordered|a|b|c|start=5}}</pre>
{{#invoke:list|ordered|a|b|c|start=5}}
<pre>{{#invoke:list|ordered|a|b|c|start=-5}}</pre>
{{#invoke:list|ordered|a|b|c|start=-5}}
|def=1|type=SignedNumber|status=Optional}}
{{TemplateData/entry|name=olType|param=type|desc=Ordered list type. <pre><ol type=""></pre> [https://developer.mozilla.org/de/docs/Web/HTML/Element/ol#Attribute MDN (ol)]. Requires <code>listType</code> <nowiki>[ "ordered" | "horizontal_ordered" ]</nowiki>. It's recommended to use <code>style</code>,<code>class</code> or param <code>list_style_type</code> instead|example=
<pre>{{#invoke:list|ordered|a|b|c|type=i}}</pre>
{{#invoke:list|ordered|a|b|c|type=i}}
<pre>{{#invoke:list|ordered|a|b|c|type=a}}</pre>
{{#invoke:list|ordered|a|b|c|type=a}}
|def=1|type=<nowiki>[ "1" | "a" | "A" | "i" | "I" ]</nowiki>|status=Optional}}
{{TemplateData/entry|name=cssType|param=list_style_type|desc=Recommended list style type. Uses the css attribute <code>list-style-type</code>|example=
<pre>{{#invoke:list|ordered|a|b|c|list_style_type=lower-alpha}}</pre>
{{#invoke:list|ordered|a|b|c|list_style_type=lower-alpha}}
<pre>{{#invoke:list|ordered|a|b|c|list_style_type=lower-greek}}</pre>
{{#invoke:list|ordered|a|b|c|list_style_type=lower-greek}}
<pre>{{#invoke:list|ordered|a|b|c|list_style_type=decimal-leading-zero}}</pre>
{{#invoke:list|ordered|a|b|c|list_style_type=decimal-leading-zero}}
|def=NULL|type=[https://developer.mozilla.org/en-US/docs/Web/CSS/list-style-type MDN (list-style-type)]|status=Optional}}
{{TemplateData/entry|name=divClass|param=class|desc=<code>class</code> attribute for the <pre><div>...</div></pre> surrounding the list|def=NULL|type=String|status=Optional}}
{{TemplateData/entry|name=divStyle|param=style|desc=<code>style</code> attribute for the <pre><div>...</div></pre> surrounding the list|def=NULL|type=String|status=Optional}}
{{TemplateData/entry|name=listStyle|param=list_style|desc=<code>style</code> attribute for the list|def=NULL|type=String|status=Optional}}
{{TemplateData/entry|name=itemStyle|param=item_style|desc=<code>style</code> attribute for the list items|def=NULL|type=String|status=Optional}}
{{TemplateData/entry|name=itemXStyle|param=item1_style...itemX_style|desc=<code>style</code> attribute for item x in list|def=NULL|type=String|status=Optional}}
{{TemplateData/entry|name=itemXValue|param=item1_value...itemX_value|desc=<code>value</code> attribute for item x in list|def=NULL|type=String|status=Optional}}
{{TemplateData/entry|name=listIndent|param=indent|desc=Set <code>margin-left</code> for list (<code>intent * 1.6 em</code>)|def=NULL|type=String|status=Optional}}
}}

== Examples ==

{{#invoke:list|bulleted|First item|Second item|Third item|item1_style=background-color:yellow;|item2_style=background-color:silver;color:black;}}

<pre>
{{#invoke:list|bulleted|First item|Second item|Third item|item1_style=background-color:yellow;|item2_style=background-color:silver;color:black;}}
</pre>

Module:List/doc

2020-08-31T22:36:05Z

Streetclaw: Created page with "Template for creating a unified parameter format for templates == About == Creates a list that displays Template parameter in a unified format. == Parameter == {{TemplateDat..."

Template for creating a unified parameter format for templates

== About ==
Creates a list that displays Template parameter in a unified format.

== Parameter ==
{{TemplateData|
{{TemplateData/entry|name=listType|param=1|desc=List type|example=
<pre>{{#invoke:list|bulleted|a|b|c}}</pre>
{{#invoke:list|bulleted|a|b|c}}
<pre>{{#invoke:list|unbulleted|a|b|c}}</pre>
{{#invoke:list|unbulleted|a|b|c}}
<pre>{{#invoke:list|horizontal|a|b|c}}</pre>
{{#invoke:list|horizontal|a|b|c}}
<pre>{{#invoke:list|ordered|a|b|c}}</pre>
{{#invoke:list|ordered|a|b|c}}
<pre>{{#invoke:list|horizontal_ordered|a|b|c}}</pre>
{{#invoke:list|horizontal_ordered|a|b|c}}
|def=NULL|type=<nowiki>[ "bulleted" | "unbulleted" | "horizontal" | "ordered" | "horizontal_ordered" ]</nowiki>|status=Required}}
{{TemplateData/entry|name=listEntries|param=2...x|desc=List entries|def=NULL|type=WikiCode|status=Optional}}
{{TemplateData/entry|name=olStart|param=start|desc=Start entry. <pre><ol start=""></pre> [https://developer.mozilla.org/de/docs/Web/HTML/Element/ol#Attribute MDN (ol)]. Requires <code>listType</code> <nowiki>[ "ordered" | "horizontal_ordered" ]</nowiki>|example=
<pre>{{#invoke:list|ordered|a|b|c|start=5}}</pre>
{{#invoke:list|ordered|a|b|c|start=5}}
<pre>{{#invoke:list|ordered|a|b|c|start=-5}}</pre>
{{#invoke:list|ordered|a|b|c|start=-5}}
|def=1|type=SignedNumber|status=Optional}}
{{TemplateData/entry|name=olType|param=type|desc=Ordered list type. <pre><ol type=""></pre> [https://developer.mozilla.org/de/docs/Web/HTML/Element/ol#Attribute MDN (ol)]. Requires <code>listType</code> <nowiki>[ "ordered" | "horizontal_ordered" ]</nowiki>. It's recommended to use <code>style</code>,<code>class</code> or param <code>list_style_type</code> instead|example=
<pre>{{#invoke:list|ordered|a|b|c|type=i}}</pre>
{{#invoke:list|ordered|a|b|c|type=i}}
<pre>{{#invoke:list|ordered|a|b|c|type=a}}</pre>
{{#invoke:list|ordered|a|b|c|type=a}}
|def=1|type=<nowiki>[ "1" | "a" | "A" | "i" | "I" ]</nowiki>|status=Optional}}
{{TemplateData/entry|name=cssType|param=list_style_type|desc=Recommended list style type. Uses the css attribute <code>list-style-type</code>|example=
<pre>{{#invoke:list|ordered|a|b|c|list_style_type=lower-alpha}}</pre>
{{#invoke:list|ordered|a|b|c|list_style_type=lower-alpha}}
<pre>{{#invoke:list|ordered|a|b|c|list_style_type=lower-greek}}</pre>
{{#invoke:list|ordered|a|b|c|list_style_type=lower-greek}}
<pre>{{#invoke:list|ordered|a|b|c|list_style_type=decimal-leading-zero}}</pre>
{{#invoke:list|ordered|a|b|c|list_style_type=decimal-leading-zero}}
|def=NULL|type=[https://developer.mozilla.org/en-US/docs/Web/CSS/list-style-type MDN (list-style-type)]|status=Optional}}
{{TemplateData/entry|name=divClass|param=class|desc=<code>class</code> attribute for the <pre><div>...</div></pre> surrounding the list|def=NULL|type=String|status=Optional}}
{{TemplateData/entry|name=divStyle|param=style|desc=<code>style</code> attribute for the <pre><div>...</div></pre> surrounding the list|def=NULL|type=String|status=Optional}}
{{TemplateData/entry|name=listStyle|param=list_style|desc=<code>style</code> attribute for the list|def=NULL|type=String|status=Optional}}
{{TemplateData/entry|name=itemStyle|param=item_style|desc=<code>style</code> attribute for the list items|def=NULL|type=String|status=Optional}}
{{TemplateData/entry|name=itemXStyle|param=item1_style...itemX_style|desc=<code>style</code> attribute for item x in list|def=NULL|type=String|status=Optional}}
{{TemplateData/entry|name=itemXValue|param=item1_value...itemX_value|desc=<code>value</code> attribute for item x in list|def=NULL|type=String|status=Optional}}
{{TemplateData/entry|name=listIndent|param=indent|desc=Set <code>margin-left</code> for list (<code>intent * 1.6 em</code>)|def=NULL|type=String|status=Optional}}
}}

== Examples ==

{{#invoke:list|bulleted|First item|Second item|Third item|item1_style=background-color:yellow;|item2_style=background-color:silver;color:black;}}

<pre>
{{#invoke:list|bulleted|First item|Second item|Third item|item1_style=background-color:yellow;|item2_style=background-color:silver;color:black;}}
</pre>

Template:TemplateData/doc

2020-08-31T22:35:35Z

Streetclaw: Undo revision 141 by Streetclaw (talk)

Template for creating a unified parameter format for templates

== About ==
Creates a list that displays Template parameter in a unified format.

== Parameter ==
{{TemplateData|
{{TemplateData/entry|name=Entries|param=1|desc=Parameter list|def=NULL|type=1 {[[Template:TemplateData/entry]]}|status=Required}}
}}

== Examples ==

'''Complete example:'''

{{TemplateData|
{{TemplateData/entry|name=Example name|alias1=Example alias 1|alias2=Example alias 2|alias3=Example alias 3|param=example param|desc=example description|def=NULL|example=xyz|type=String|status=Required}}
}}

<pre>
{{TemplateData|
{{TemplateData/entry|name=Example name|alias1=Example alias 1|alias2=Example alias 2|alias3=Example alias 3|param=example param|desc=example description|def=NULL|example=xyz|type=String|status=Required}}
}}
</pre>

Template:TemplateData/doc

2020-08-31T22:34:49Z

Streetclaw: doc added

Module:Arguments

2020-08-31T21:22:08Z

Streetclaw: Created page with "-- This module provides easy processing of arguments passed to Scribunto from -- #invoke. It is intended for use by other Lua modules, and should not be -- called from #invoke..."

-- This module provides easy processing of arguments passed to Scribunto from
-- #invoke. It is intended for use by other Lua modules, and should not be
-- called from #invoke directly.

local libraryUtil = require('libraryUtil')
local checkType = libraryUtil.checkType

local arguments = {}

-- Generate four different tidyVal functions, so that we don't have to check the
-- options every time we call it.

local function tidyValDefault(key, val)
if type(val) == 'string' then
val = val:match('^%s*(.-)%s*$')
if val == '' then
return nil
else
return val
end
else
return val
end
end

local function tidyValTrimOnly(key, val)
if type(val) == 'string' then
return val:match('^%s*(.-)%s*$')
else
return val
end
end

local function tidyValRemoveBlanksOnly(key, val)
if type(val) == 'string' then
if val:find('%S') then
return val
else
return nil
end
else
return val
end
end

local function tidyValNoChange(key, val)
return val
end

local function matchesTitle(given, title)
local tp = type( given )
return (tp == 'string' or tp == 'number') and mw.title.new( given ).prefixedText == title
end

local translate_mt = { __index = function(t, k) return k end }

function arguments.getArgs(frame, options)
checkType('getArgs', 1, frame, 'table', true)
checkType('getArgs', 2, options, 'table', true)
frame = frame or {}
options = options or {}

--[[
-- Set up argument translation.
--]]
options.translate = options.translate or {}
if getmetatable(options.translate) == nil then
setmetatable(options.translate, translate_mt)
end
if options.backtranslate == nil then
options.backtranslate = {}
for k,v in pairs(options.translate) do
options.backtranslate[v] = k
end
end
if options.backtranslate and getmetatable(options.backtranslate) == nil then
setmetatable(options.backtranslate, {
__index = function(t, k)
if options.translate[k] ~= k then
return nil
else
return k
end
end
})
end

--[[
-- Get the argument tables. If we were passed a valid frame object, get the
-- frame arguments (fargs) and the parent frame arguments (pargs), depending
-- on the options set and on the parent frame's availability. If we weren't
-- passed a valid frame object, we are being called from another Lua module
-- or from the debug console, so assume that we were passed a table of args
-- directly, and assign it to a new variable (luaArgs).
--]]
local fargs, pargs, luaArgs
if type(frame.args) == 'table' and type(frame.getParent) == 'function' then
if options.wrappers then
--[[
-- The wrappers option makes Module:Arguments look up arguments in
-- either the frame argument table or the parent argument table, but
-- not both. This means that users can use either the #invoke syntax
-- or a wrapper template without the loss of performance associated
-- with looking arguments up in both the frame and the parent frame.
-- Module:Arguments will look up arguments in the parent frame
-- if it finds the parent frame's title in options.wrapper;
-- otherwise it will look up arguments in the frame object passed
-- to getArgs.
--]]
local parent = frame:getParent()
if not parent then
fargs = frame.args
else
local title = parent:getTitle():gsub('/sandbox$', '')
local found = false
if matchesTitle(options.wrappers, title) then
found = true
elseif type(options.wrappers) == 'table' then
for _,v in pairs(options.wrappers) do
if matchesTitle(v, title) then
found = true
break
end
end
end

-- We test for false specifically here so that nil (the default) acts like true.
if found or options.frameOnly == false then
pargs = parent.args
end
if not found or options.parentOnly == false then
fargs = frame.args
end
end
else
-- options.wrapper isn't set, so check the other options.
if not options.parentOnly then
fargs = frame.args
end
if not options.frameOnly then
local parent = frame:getParent()
pargs = parent and parent.args or nil
end
end
if options.parentFirst then
fargs, pargs = pargs, fargs
end
else
luaArgs = frame
end

-- Set the order of precedence of the argument tables. If the variables are
-- nil, nothing will be added to the table, which is how we avoid clashes
-- between the frame/parent args and the Lua args.
local argTables = {fargs}
argTables[#argTables + 1] = pargs
argTables[#argTables + 1] = luaArgs

--[[
-- Generate the tidyVal function. If it has been specified by the user, we
-- use that; if not, we choose one of four functions depending on the
-- options chosen. This is so that we don't have to call the options table
-- every time the function is called.
--]]
local tidyVal = options.valueFunc
if tidyVal then
if type(tidyVal) ~= 'function' then
error(
"bad value assigned to option 'valueFunc'"
.. '(function expected, got '
.. type(tidyVal)
.. ')',
2
)
end
elseif options.trim ~= false then
if options.removeBlanks ~= false then
tidyVal = tidyValDefault
else
tidyVal = tidyValTrimOnly
end
else
if options.removeBlanks ~= false then
tidyVal = tidyValRemoveBlanksOnly
else
tidyVal = tidyValNoChange
end
end

--[[
-- Set up the args, metaArgs and nilArgs tables. args will be the one
-- accessed from functions, and metaArgs will hold the actual arguments. Nil
-- arguments are memoized in nilArgs, and the metatable connects all of them
-- together.
--]]
local args, metaArgs, nilArgs, metatable = {}, {}, {}, {}
setmetatable(args, metatable)

local function mergeArgs(tables)
--[[
-- Accepts multiple tables as input and merges their keys and values
-- into one table. If a value is already present it is not overwritten;
-- tables listed earlier have precedence. We are also memoizing nil
-- values, which can be overwritten if they are 's' (soft).
--]]
for _, t in ipairs(tables) do
for key, val in pairs(t) do
if metaArgs[key] == nil and nilArgs[key] ~= 'h' then
local tidiedVal = tidyVal(key, val)
if tidiedVal == nil then
nilArgs[key] = 's'
else
metaArgs[key] = tidiedVal
end
end
end
end
end

--[[
-- Define metatable behaviour. Arguments are memoized in the metaArgs table,
-- and are only fetched from the argument tables once. Fetching arguments
-- from the argument tables is the most resource-intensive step in this
-- module, so we try and avoid it where possible. For this reason, nil
-- arguments are also memoized, in the nilArgs table. Also, we keep a record
-- in the metatable of when pairs and ipairs have been called, so we do not
-- run pairs and ipairs on the argument tables more than once. We also do
-- not run ipairs on fargs and pargs if pairs has already been run, as all
-- the arguments will already have been copied over.
--]]

metatable.__index = function (t, key)
--[[
-- Fetches an argument when the args table is indexed. First we check
-- to see if the value is memoized, and if not we try and fetch it from
-- the argument tables. When we check memoization, we need to check
-- metaArgs before nilArgs, as both can be non-nil at the same time.
-- If the argument is not present in metaArgs, we also check whether
-- pairs has been run yet. If pairs has already been run, we return nil.
-- This is because all the arguments will have already been copied into
-- metaArgs by the mergeArgs function, meaning that any other arguments
-- must be nil.
--]]
if type(key) == 'string' then
key = options.translate[key]
end
local val = metaArgs[key]
if val ~= nil then
return val
elseif metatable.donePairs or nilArgs[key] then
return nil
end
for _, argTable in ipairs(argTables) do
local argTableVal = tidyVal(key, argTable[key])
if argTableVal ~= nil then
metaArgs[key] = argTableVal
return argTableVal
end
end
nilArgs[key] = 'h'
return nil
end

metatable.__newindex = function (t, key, val)
-- This function is called when a module tries to add a new value to the
-- args table, or tries to change an existing value.
if type(key) == 'string' then
key = options.translate[key]
end
if options.readOnly then
error(
'could not write to argument table key "'
.. tostring(key)
.. '"; the table is read-only',
2
)
elseif options.noOverwrite and args[key] ~= nil then
error(
'could not write to argument table key "'
.. tostring(key)
.. '"; overwriting existing arguments is not permitted',
2
)
elseif val == nil then
--[[
-- If the argument is to be overwritten with nil, we need to erase
-- the value in metaArgs, so that __index, __pairs and __ipairs do
-- not use a previous existing value, if present; and we also need
-- to memoize the nil in nilArgs, so that the value isn't looked
-- up in the argument tables if it is accessed again.
--]]
metaArgs[key] = nil
nilArgs[key] = 'h'
else
metaArgs[key] = val
end
end

local function translatenext(invariant)
local k, v = next(invariant.t, invariant.k)
invariant.k = k
if k == nil then
return nil
elseif type(k) ~= 'string' or not options.backtranslate then
return k, v
else
local backtranslate = options.backtranslate[k]
if backtranslate == nil then
-- Skip this one. This is a tail call, so this won't cause stack overflow
return translatenext(invariant)
else
return backtranslate, v
end
end
end

metatable.__pairs = function ()
-- Called when pairs is run on the args table.
if not metatable.donePairs then
mergeArgs(argTables)
metatable.donePairs = true
end
return translatenext, { t = metaArgs }
end

local function inext(t, i)
-- This uses our __index metamethod
local v = t[i + 1]
if v ~= nil then
return i + 1, v
end
end

metatable.__ipairs = function (t)
-- Called when ipairs is run on the args table.
return inext, t, 0
end

return args
end

return arguments

Module:List

2020-08-31T21:14:43Z

Streetclaw: Lua module test (list)

-- This module outputs different kinds of lists. At the moment, bulleted,
-- unbulleted, horizontal, ordered, and horizontal ordered lists are supported.

local libUtil = require('libraryUtil')
local checkType = libUtil.checkType
local mTableTools = require('Module:TableTools')

local p = {}

local listTypes = {
['bulleted'] = true,
['unbulleted'] = true,
['horizontal'] = true,
['ordered'] = true,
['horizontal_ordered'] = true
}

function p.makeListData(listType, args)
-- Constructs a data table to be passed to p.renderList.
local data = {}

-- Classes
data.classes = {}
if listType == 'horizontal' or listType == 'horizontal_ordered' then
table.insert(data.classes, 'hlist')
elseif listType == 'unbulleted' then
table.insert(data.classes, 'plainlist')
end
table.insert(data.classes, args.class)

-- Main div style
data.style = args.style

-- Indent for horizontal lists
if listType == 'horizontal' or listType == 'horizontal_ordered' then
local indent = tonumber(args.indent)
indent = indent and indent * 1.6 or 0
if indent > 0 then
data.marginLeft = indent .. 'em'
end
end

-- List style types for ordered lists
-- This could be "1, 2, 3", "a, b, c", or a number of others. The list style
-- type is either set by the "type" attribute or the "list-style-type" CSS
-- property.
if listType == 'ordered' or listType == 'horizontal_ordered' then
data.listStyleType = args.list_style_type or args['list-style-type']
data.type = args['type']

-- Detect invalid type attributes and attempt to convert them to
-- list-style-type CSS properties.
if data.type
and not data.listStyleType
and not tostring(data.type):find('^%s*[1AaIi]%s*$')
then
data.listStyleType = data.type
data.type = nil
end
end

-- List tag type
if listType == 'ordered' or listType == 'horizontal_ordered' then
data.listTag = 'ol'
else
data.listTag = 'ul'
end

-- Start number for ordered lists
data.start = args.start
if listType == 'horizontal_ordered' then
-- Apply fix to get start numbers working with horizontal ordered lists.
local startNum = tonumber(data.start)
if startNum then
data.counterReset = 'listitem ' .. tostring(startNum - 1)
end
end

-- List style
-- ul_style and ol_style are included for backwards compatibility. No
-- distinction is made for ordered or unordered lists.
data.listStyle = args.list_style

-- List items
-- li_style is included for backwards compatibility. item_style was included
-- to be easier to understand for non-coders.
data.itemStyle = args.item_style or args.li_style
data.items = {}
for i, num in ipairs(mTableTools.numKeys(args)) do
local item = {}
item.content = args[num]
item.style = args['item' .. tostring(num) .. '_style']
or args['item_style' .. tostring(num)]
item.value = args['item' .. tostring(num) .. '_value']
or args['item_value' .. tostring(num)]
table.insert(data.items, item)
end

return data
end

function p.renderList(data)
-- Renders the list HTML.

-- Return the blank string if there are no list items.
if type(data.items) ~= 'table' or #data.items < 1 then
return ''
end

-- Render the main div tag.
local root = mw.html.create('div')
for i, class in ipairs(data.classes or {}) do
root:addClass(class)
end
root:css{['margin-left'] = data.marginLeft}
if data.style then
root:cssText(data.style)
end

-- Render the list tag.
local list = root:tag(data.listTag or 'ul')
list
:attr{start = data.start, type = data.type}
:css{
['counter-reset'] = data.counterReset,
['list-style-type'] = data.listStyleType
}
if data.listStyle then
list:cssText(data.listStyle)
end

-- Render the list items
for i, t in ipairs(data.items or {}) do
local item = list:tag('li')
if data.itemStyle then
item:cssText(data.itemStyle)
end
if t.style then
item:cssText(t.style)
end
item
:attr{value = t.value}
:wikitext(t.content)
end

return tostring(root)
end

function p.makeList(listType, args)
if not listType or not listTypes[listType] then
error(string.format(
"bad argument #1 to 'makeList' ('%s' is not a valid list type)",
tostring(listType)
), 2)
end
checkType('makeList', 2, args, 'table')
local data = p.makeListData(listType, args)
return p.renderList(data)
end

for listType in pairs(listTypes) do
p[listType] = function (frame)
local mArguments = require('Module:Arguments')
local origArgs = mArguments.getArgs(frame)
-- Copy all the arguments to a new table, for faster indexing.
local args = {}
for k, v in pairs(origArgs) do
args[k] = v
end
return p.makeList(listType, args)
end
end

return p

Module:TableTools

2020-08-31T21:13:53Z

Streetclaw: Lua module test (table tools)

--[[
------------------------------------------------------------------------------------
-- TableTools --
-- --
-- This module includes a number of functions for dealing with Lua tables. --
-- It is a meta-module, meant to be called from other Lua modules, and should --
-- not be called directly from #invoke. --
------------------------------------------------------------------------------------
--]]

local libraryUtil = require('libraryUtil')

local p = {}

-- Define often-used variables and functions.
local floor = math.floor
local infinity = math.huge
local checkType = libraryUtil.checkType
local checkTypeMulti = libraryUtil.checkTypeMulti

--[[
------------------------------------------------------------------------------------
-- isPositiveInteger
--
-- This function returns true if the given value is a positive integer, and false
-- if not. Although it doesn't operate on tables, it is included here as it is
-- useful for determining whether a given table key is in the array part or the
-- hash part of a table.
------------------------------------------------------------------------------------
--]]
function p.isPositiveInteger(v)
if type(v) == 'number' and v >= 1 and floor(v) == v and v < infinity then
return true
else
return false
end
end

--[[
------------------------------------------------------------------------------------
-- isNan
--
-- This function returns true if the given number is a NaN value, and false
-- if not. Although it doesn't operate on tables, it is included here as it is
-- useful for determining whether a value can be a valid table key. Lua will
-- generate an error if a NaN is used as a table key.
------------------------------------------------------------------------------------
--]]
function p.isNan(v)
if type(v) == 'number' and tostring(v) == '-nan' then
return true
else
return false
end
end

--[[
------------------------------------------------------------------------------------
-- shallowClone
--
-- This returns a clone of a table. The value returned is a new table, but all
-- subtables and functions are shared. Metamethods are respected, but the returned
-- table will have no metatable of its own.
------------------------------------------------------------------------------------
--]]
function p.shallowClone(t)
local ret = {}
for k, v in pairs(t) do
ret[k] = v
end
return ret
end

--[[
------------------------------------------------------------------------------------
-- removeDuplicates
--
-- This removes duplicate values from an array. Non-positive-integer keys are
-- ignored. The earliest value is kept, and all subsequent duplicate values are
-- removed, but otherwise the array order is unchanged.
------------------------------------------------------------------------------------
--]]
function p.removeDuplicates(t)
checkType('removeDuplicates', 1, t, 'table')
local isNan = p.isNan
local ret, exists = {}, {}
for i, v in ipairs(t) do
if isNan(v) then
-- NaNs can't be table keys, and they are also unique, so we don't need to check existence.
ret[#ret + 1] = v
else
if not exists[v] then
ret[#ret + 1] = v
exists[v] = true
end
end
end
return ret
end

--[[
------------------------------------------------------------------------------------
-- numKeys
--
-- This takes a table and returns an array containing the numbers of any numerical
-- keys that have non-nil values, sorted in numerical order.
------------------------------------------------------------------------------------
--]]
function p.numKeys(t)
checkType('numKeys', 1, t, 'table')
local isPositiveInteger = p.isPositiveInteger
local nums = {}
for k, v in pairs(t) do
if isPositiveInteger(k) then
nums[#nums + 1] = k
end
end
table.sort(nums)
return nums
end

--[[
------------------------------------------------------------------------------------
-- affixNums
--
-- This takes a table and returns an array containing the numbers of keys with the
-- specified prefix and suffix. For example, for the table
-- {a1 = 'foo', a3 = 'bar', a6 = 'baz'} and the prefix "a", affixNums will
-- return {1, 3, 6}.
------------------------------------------------------------------------------------
--]]
function p.affixNums(t, prefix, suffix)
checkType('affixNums', 1, t, 'table')
checkType('affixNums', 2, prefix, 'string', true)
checkType('affixNums', 3, suffix, 'string', true)

local function cleanPattern(s)
-- Cleans a pattern so that the magic characters ()%.[]*+-?^$ are interpreted literally.
s = s:gsub('([%(%)%%%.%[%]%*%+%-%?%^%$])', '%%%1')
return s
end

prefix = prefix or ''
suffix = suffix or ''
prefix = cleanPattern(prefix)
suffix = cleanPattern(suffix)
local pattern = '^' .. prefix .. '([1-9]%d*)' .. suffix .. '$'

local nums = {}
for k, v in pairs(t) do
if type(k) == 'string' then
local num = mw.ustring.match(k, pattern)
if num then
nums[#nums + 1] = tonumber(num)
end
end
end
table.sort(nums)
return nums
end

--[[
------------------------------------------------------------------------------------
-- numData
--
-- Given a table with keys like ("foo1", "bar1", "foo2", "baz2"), returns a table
-- of subtables in the format
-- { [1] = {foo = 'text', bar = 'text'}, [2] = {foo = 'text', baz = 'text'} }
-- Keys that don't end with an integer are stored in a subtable named "other".
-- The compress option compresses the table so that it can be iterated over with
-- ipairs.
------------------------------------------------------------------------------------
--]]
function p.numData(t, compress)
checkType('numData', 1, t, 'table')
checkType('numData', 2, compress, 'boolean', true)
local ret = {}
for k, v in pairs(t) do
local prefix, num = mw.ustring.match(tostring(k), '^([^0-9]*)([1-9][0-9]*)$')
if num then
num = tonumber(num)
local subtable = ret[num] or {}
if prefix == '' then
-- Positional parameters match the blank string; put them at the start of the subtable instead.
prefix = 1
end
subtable[prefix] = v
ret[num] = subtable
else
local subtable = ret.other or {}
subtable[k] = v
ret.other = subtable
end
end
if compress then
local other = ret.other
ret = p.compressSparseArray(ret)
ret.other = other
end
return ret
end

--[[
------------------------------------------------------------------------------------
-- compressSparseArray
--
-- This takes an array with one or more nil values, and removes the nil values
-- while preserving the order, so that the array can be safely traversed with
-- ipairs.
------------------------------------------------------------------------------------
--]]
function p.compressSparseArray(t)
checkType('compressSparseArray', 1, t, 'table')
local ret = {}
local nums = p.numKeys(t)
for _, num in ipairs(nums) do
ret[#ret + 1] = t[num]
end
return ret
end

--[[
------------------------------------------------------------------------------------
-- sparseIpairs
--
-- This is an iterator for sparse arrays. It can be used like ipairs, but can
-- handle nil values.
------------------------------------------------------------------------------------
--]]
function p.sparseIpairs(t)
checkType('sparseIpairs', 1, t, 'table')
local nums = p.numKeys(t)
local i = 0
local lim = #nums
return function ()
i = i + 1
if i <= lim then
local key = nums[i]
return key, t[key]
else
return nil, nil
end
end
end

--[[
------------------------------------------------------------------------------------
-- size
--
-- This returns the size of a key/value pair table. It will also work on arrays,
-- but for arrays it is more efficient to use the # operator.
------------------------------------------------------------------------------------
--]]

function p.size(t)
checkType('size', 1, t, 'table')
local i = 0
for k in pairs(t) do
i = i + 1
end
return i
end

local function defaultKeySort(item1, item2)
-- "number" < "string", so numbers will be sorted before strings.
local type1, type2 = type(item1), type(item2)
if type1 ~= type2 then
return type1 < type2
else -- This will fail with table, boolean, function.
return item1 < item2
end
end

--[[
Returns a list of the keys in a table, sorted using either a default
comparison function or a custom keySort function.
]]
function p.keysToList(t, keySort, checked)
if not checked then
checkType('keysToList', 1, t, 'table')
checkTypeMulti('keysToList', 2, keySort, { 'function', 'boolean', 'nil' })
end

local list = {}
local index = 1
for key, value in pairs(t) do
list[index] = key
index = index + 1
end

if keySort ~= false then
keySort = type(keySort) == 'function' and keySort or defaultKeySort

table.sort(list, keySort)
end

return list
end

--[[
Iterates through a table, with the keys sorted using the keysToList function.
If there are only numerical keys, sparseIpairs is probably more efficient.
]]
function p.sortedPairs(t, keySort)
checkType('sortedPairs', 1, t, 'table')
checkType('sortedPairs', 2, keySort, 'function', true)

local list = p.keysToList(t, keySort, true)

local i = 0
return function()
i = i + 1
local key = list[i]
if key ~= nil then
return key, t[key]
else
return nil, nil
end
end
end

--[[
Returns true if all keys in the table are consecutive integers starting at 1.
--]]
function p.isArray(t)
checkType("isArray", 1, t, "table")

local i = 0
for k, v in pairs(t) do
i = i + 1
if t[i] == nil then
return false
end
end
return true
end

-- { "a", "b", "c" } -> { a = 1, b = 2, c = 3 }
function p.invert(array)
checkType("invert", 1, array, "table")

local map = {}
for i, v in ipairs(array) do
map[v] = i
end

return map
end

--[[
{ "a", "b", "c" } -> { ["a"] = true, ["b"] = true, ["c"] = true }
--]]
function p.listToSet(t)
checkType("listToSet", 1, t, "table")

local set = {}
for _, item in ipairs(t) do
set[item] = true
end

return set
end

--[[
Recursive deep copy function.
Preserves identities of subtables.

]]
local function _deepCopy(orig, includeMetatable, already_seen)
-- Stores copies of tables indexed by the original table.
already_seen = already_seen or {}

local copy = already_seen[orig]
if copy ~= nil then
return copy
end

if type(orig) == 'table' then
copy = {}
for orig_key, orig_value in pairs(orig) do
copy[deepcopy(orig_key, includeMetatable, already_seen)] = deepcopy(orig_value, includeMetatable, already_seen)
end
already_seen[orig] = copy

if includeMetatable then
local mt = getmetatable(orig)
if mt ~= nil then
local mt_copy = deepcopy(mt, includeMetatable, already_seen)
setmetatable(copy, mt_copy)
already_seen[mt] = mt_copy
end
end
else -- number, string, boolean, etc
copy = orig
end
return copy
end

function p.deepCopy(orig, noMetatable, already_seen)
checkType("deepCopy", 3, already_seen, "table", true)

return _deepCopy(orig, not noMetatable, already_seen)
end

--[[
Concatenates all values in the table that are indexed by a number, in order.
sparseConcat{ a, nil, c, d } => "acd"
sparseConcat{ nil, b, c, d } => "bcd"
]]
function p.sparseConcat(t, sep, i, j)
local list = {}

local list_i = 0
for _, v in p.sparseIpairs(t) do
list_i = list_i + 1
list[list_i] = v
end

return table.concat(list, sep, i, j)
end

--[[
-- This returns the length of a table, or the first integer key n counting from
-- 1 such that t[n + 1] is nil. It is similar to the operator #, but may return
-- a different value when there are gaps in the array portion of the table.
-- Intended to be used on data loaded with mw.loadData. For other tables, use #.
-- Note: #frame.args in frame object always be set to 0, regardless of
-- the number of unnamed template parameters, so use this function for
-- frame.args.
--]]
function p.length(t)
local i = 1
while t[i] ~= nil do
i = i + 1
end
return i - 1
end

function p.inArray(arr, valueToFind)
checkType("inArray", 1, arr, "table")

-- if valueToFind is nil, error?

for _, v in ipairs(arr) do
if v == valueToFind then
return true
end
end

return false
end

return p

User talk:Streetclaw

2020-08-15T15:09:10Z

Streetclaw: Created blank page

User:Streetclaw

2020-08-15T15:04:56Z

Streetclaw: Created page with "* Discord: Streetclaw#8113 * Github: github:streetclaw Category:CCDirectLink members"

* Discord: Streetclaw#8113
* Github: [[github:streetclaw]]

[[Category:CCDirectLink members]]

Category:Documented template

2020-08-15T15:01:48Z

Streetclaw: Created page with "Lists all documented templates."

Lists all documented templates.

Template:Doc/doc

2020-08-15T14:46:28Z

Streetclaw: Documentation information added

Template to describe and document templates.

== About ==
This template should be used for the documentation of templates.

== Parameter ==
None

== Examples ==

Inserts the content of [[Template:Doc/doc]] if used in [[Template:Doc]].

<pre>
{{doc}}
</pre>

The template should only be used inside of <code>noinclude</code>.

<pre>
<noinclude>{{doc}}</noinclude>
</pre>

Template:TemplateData/entry/doc

2020-08-15T14:38:08Z

Streetclaw: /* Examples */ unused param removed

Template for creating a unified parameter format for templates

== About ==
Creates a list that displays Template parameter in a unified format.
This template creates a single entry for the Required template [[Template:TemplateData]].

== Parameter ==
{{TemplateData|
{{TemplateData/entry|name=Parameter title|param=name|desc=Specify a title for a parameter of the template documentation|def=NULL|type=String|status=Required}}
{{TemplateData/entry|name=Parameter name|param=param|desc=Specify a name for a parameter of the template documentation|def=NULL|type=String|status=Required}}
{{TemplateData/entry|name=Parameter alias1|param=alias1|desc=Specify a alias for a parameter of the template documentation|def=NULL|type=String|status=Optional}}
{{TemplateData/entry|name=Parameter alias2|param=alias2|desc=Specify a alias for a parameter of the template documentation|def=NULL|type=String|status=Optional}}
{{TemplateData/entry|name=Parameter alias3|param=alias3|desc=Specify a alias for a parameter of the template documentation|def=NULL|type=String|status=Optional}}
{{TemplateData/entry|name=Parameter Description|param=desc|desc=Specify a description for a parameter of the template documentation|def=no description|type=WikiCode|status=Recommended}}
{{TemplateData/entry|name=Parameter Example|param=example|desc=Specify an example for a parameter of the template documentation|def=no example|type=WikiCode|status=Recommended}}
{{TemplateData/entry|name=Parameter type|param=type|desc=Specify a type for a parameter of the template documentation: [[#Data_Dictionary_Notation_.28DDN.29_for_types|Data Dictionary Notation]]|def=NULL|type=[[#Data_Dictionary_Notation_.28DDN.29_for_types|DDNCode]]|status=Required}}
{{TemplateData/entry|name=Parameter status|param=status|desc=Specify a status for a parameter of the template documentation|def=NULL|type=<nowiki>["Required" | "Recommended" | "Optional" | "Deprecated" ]</nowiki>|status=Required}}
{{TemplateData/entry|name=Auto pre|param=autoPre|desc=Automatic pre for examples|def=0|type=Boolean|status=Optional}}
}}

== Examples ==

'''Complete example:'''

{{TemplateData|
{{TemplateData/entry|name=Example name|alias1=Example alias 1|alias2=Example alias 2|alias3=Example alias 3|param=example param|desc=example description|def=NULL|example=xyz|type=String|status=Required}}
{{TemplateData/entry|name=Auto pre name B|alias1=B alias 1|alias2=B alias 2|alias3=B alias 3|param=B param|desc=B description|def=NULL|example=
* List example with containing templates and HTML tags
|type=String|status=Required|autoPre=1}}
{{TemplateData/entry|name=Deprecated Example name|alias1=Deprecated alias 1|alias2=Deprecated alias 2|alias3=Deprecated alias 3|param=deprecated param|desc=deprecated description|def=NULL|example=xyz|type=String|status=Deprecated}}
}}

<pre>
{{TemplateData|
{{TemplateData/entry|name=Example name|alias1=Example alias 1|alias2=Example alias 2|alias3=Example alias 3|param=example param|desc=example description|def=NULL|example=xyz|type=String|status=Required}}
{{TemplateData/entry|name=Auto pre name B|alias1=B alias 1|alias2=B alias 2|alias3=B alias 3|param=B param|desc=B description|def=NULL|example=
* List example with containing templates and HTML tags
|type=String|status=Required|autoPre=1}}
{{TemplateData/entry|name=Deprecated Example name|alias1=Deprecated alias 1|alias2=Deprecated alias 2|alias3=Deprecated alias 3|param=deprecated param|desc=deprecated description|def=NULL|example=xyz|type=String|status=Deprecated}}
}}
</pre>

== Data Dictionary Notation (DDN) for types ==

The [http://users.csc.calpoly.edu/~jdalbey/SWE/DDnotation.html Data Dictionary Notation (DDN)] is a modified modified [https://en.wikipedia.org/wiki/Backus%E2%80%93Naur_form BNF notation] (which is used in [https://en.wikipedia.org/wiki/Data_dictionary Data Dictionaries]) to describes the structure of data entries. The BNF and DDN notation is used in the field of [https://en.wikipedia.org/wiki/Software_engineering Software engineering (SWE)]. In this case it describes how types have to be structured.

The used DDN Notation is slightly different than the linked DDN Notation:
* The upper limit is '''not''' superscript
* Can have a lower limit
* Can have optional parts

{| class="wikitable"
|-
! Type
! Notation
! Description
|-
| Sequence
| +
| Sequence of definitions
|-
| Alternative
| <nowiki>[...|...]</nowiki>
| Only one element out of this list
|-
| Repetition
| {...}
| Repetition of the definition
|-
| Repetition
| 2 {...}
| Repetition of the definition with the minimum of two
|-
| Repetition
| {...} 5
| Repetition of the definition with the maximum of five
|-
| Repetition
| 1 {...} 6
| Repetition of the definition with the minimum of one and the maximum of six
|-
| Option
| (...)
| Optional definition
|-
| Specific value
| "..."
| fix definition
|}

=== Predefined ===

All predefined Types can be used directly or inside DDNCode

{| class="wikitable"
|-
! Type
! Definition
! Comment
|-
| NULL
| <nowiki>""</nowiki>
| Empty
|-
| NonzeroDigit
| <nowiki>["1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"]</nowiki>
| Single character, 1 - 9
|-
| Digit
| <nowiki>["0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"]</nowiki>
| Single character, 0 - 9
|-
| LowerAlphabet
| <nowiki>["a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z" ]</nowiki>
| Single character, a - z
|-
| UpperAlphabet
| <nowiki>["A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z"]</nowiki>
| Single character, A - Z
|-
| Alphabet
| <nowiki>[LowerAlphabet | UpperAlphabet]</nowiki>
| Single character, a - z / A - Z
|-
| Ascii
| <nowiki>1 {Ascii} 1</nowiki>
| [https://en.wikipedia.org/wiki/ASCII ASCII] character
|-
| Char
| <nowiki>1 {Char} 1</nowiki>
| [https://en.wikipedia.org/wiki/UTF-8 UTF-8] character
|-
| String
| <nowiki>1 {Char}</nowiki>
| One or more UTF-8 characters
|-
| AsciiString
| <nowiki>1 {Ascii}</nowiki>
| One or more ASCII characters
|-
| WikiCode
| <nowiki>1 {WikiCode} 1</nowiki>
| Any wiki code
|-
| DDNCode
| <nowiki>1 {DDNCode} 1</nowiki>
| Any DDNCode (links are allowed)
|-
| Number
| <nowiki>1 {Digit}</nowiki>
| Any natural number with zero
|-
| Decimal
| <nowiki>1 {Digit} + ( "." + 1 {Digit} )</nowiki>
| Any natural number with zero
|-
| NonzeroNumber
| <nowiki>[ 1 {NonzeroDigit} 1 | 2 {Digit} ]</nowiki>
| Any natural number without zero
|-
| SignedNumber
| <nowiki>[ "-" + 1 {NonzeroDigit} 1 | 1 {Digit} 1 | ("-") + 2 {Digit} ]</nowiki>
| Any Integer (doesn't allow -0 only 0)
|-
| PercentValue
| <nowiki>[ 1 {Digit} 2 | "100" ]</nowiki>
| Any natural number from 0 to 100
|-
| SignedPercentValue
| <nowiki>[ "-" + 1 {NonzeroDigit} 1 | 1 {Digit} 1 | ("-") + 2 {Digit} 2 | ("-") + "100" ]</nowiki>
| Any natural number from 0 to 100 and from -1 to -100
|-
| Percent
| <nowiki>PercentValue + "%"</nowiki>
| From 0% to 100% (natural number)
|-
| SignedPercent
| <nowiki>SignedPercentValue + "%"</nowiki>
| From 0% to 100% and from -1% to -100% (natural number)
|-
| Boolean
| <nowiki>["0" | "1"]</nowiki>
| 0 (off) or 1 (on)
|-
| True
| <nowiki>"1"</nowiki>
| 1 (on)
|-
| False
| <nowiki>"0"</nowiki>
| 0 (off)
|-
| Month
| <nowiki>[ 1 {NonzeroDigit} 1 | "10" | "11" | "12"]</nowiki>
| 1 - 12
|-
| Monthfill
| <nowiki>["0" + 1 {NonzeroDigit} 1 | "10" | "11" | "12"]</nowiki>
| 01, 02, 03 ... - 12
|-
| Monthname
| <nowiki>["January" | "February" | "March" | "April" | "May" | "June" | "July" | "August" | "September" | "October" | "November" | "December"]</nowiki>
| Month (name)
|-
| Day
| <nowiki>[ ( [ "1" | "2" ] ) + 1 {Digit} 1 | "30" | "31" ]</nowiki>
| 1 - 31
|-
| Dayfill
| <nowiki>[ [ "0" | 1" | "2" ] + 1 {Digit} 1 | "30" | "31" ]</nowiki>
| 01, 02, 03 ... - 31
|-
| Year
| <nowiki>1 {Digit}</nowiki>
| Any year
|-
| LabeledYear
| <nowiki>Year + [" AD" | " BC" | " AC"]</nowiki>
| Any year with label
|-
| LevelNumber
| <nowiki>[ 1 {NonzeroDigit} 1 | 2 {Digit} 2 ]</nowiki>
| 1, 2, ... - 99
|-
| LevelNumberFill
| <nowiki>[ "0" + 1 {NonzeroDigit} 1 | 2 {Digit} 2 ]</nowiki>
| 01, 02, ... - 99
|}

=== Special Predefined ===

These predefines are based on the current Template

{| class="wikitable"
|-
! Type
! Definition
! Comment
|-
| <nowiki><name></nowiki>
| <nowiki>"{{{<name>}}}"</nowiki>
| All parameter names of the current template (this means: use the same type as in <nowiki><name></nowiki>)
|-
| <nowiki><Template:<name>></nowiki>
| <nowiki>"[[Template:<name>]]"</nowiki>
| Other templates (link required for type; this means: use these template as type; used in nested templates)
|}

=== Examples ===
* String + Number + {param}
* Number + param
(param is in this example an other parameter of the template)
* String + " = " + 1 {String} 2
* String + (Number)

Template:TemplateData/doc

2020-08-15T14:34:51Z

Template for creating a unified parameter format for templates

== About ==
Creates a list that displays Template parameter in a unified format.

== Parameter ==
{{TemplateData|
{{TemplateData/entry|name=Entries|param=1|desc=Parameter list|def=NULL|type=1 {[[Template:TemplateData/entry]]}|status=Required}}
}}

== Examples ==

'''Complete example:'''

{{TemplateData|
{{TemplateData/entry|name=Example name|alias1=Example alias 1|alias2=Example alias 2|alias3=Example alias 3|param=example param|desc=example description|def=NULL|example=xyz|type=String|status=Required}}
}}

<pre>
{{TemplateData|
{{TemplateData/entry|name=Example name|alias1=Example alias 1|alias2=Example alias 2|alias3=Example alias 3|param=example param|desc=example description|def=NULL|example=xyz|type=String|status=Required}}
}}
</pre>

Template:TemplateData

2020-08-15T14:34:14Z

Streetclaw: Created page with "<noinclude>{{doc}}</noinclude><includeonly>Do not use named parameter for <code>1</code> ... <code>x</code>. The first Parameter will be automatically marked as <code>1</code>..."

<noinclude>{{doc}}</noinclude><includeonly>Do not use named parameter for <code>1</code> ... <code>x</code>. The first Parameter will be automatically marked as <code>1</code>, the second as <code>2</code> and so on.

{| class="wikitable" style="width:100%"
|-
! colspan=2 | Parameter
! Description
! Type
! Status
|-
{{{1}}}
|}
See [[Template:TemplateData]] and [[Template:TemplateData/entry]] for more information about the parameter list and [[Template:TemplateData/entry#Data Dictionary Notation (DDN) for types|DDNCode]] for more information about types and the DDN Notation</includeonly>

Template:TemplateData/entry

2020-08-15T14:33:42Z

Streetclaw: Created page with "<noinclude>{{doc}}</noinclude><includeonly>! style="width:15%; text-align:center" | {{#ifeq: {{{status}}}|Deprecated|<span style="color:red">{{{name}}}</span>|{{{name}}}}} |<c..."

<noinclude>{{doc}}</noinclude><includeonly>! style="width:15%; text-align:center" | {{#ifeq: {{{status}}}|Deprecated|<span style="color:red">{{{name}}}</span>|{{{name}}}}}
|<code>{{{param}}}</code>{{#if: {{{alias1|}}} |<br/><code>{{{alias1}}}</code>}}{{#if: {{{alias2|}}} |<br/><code>{{{alias2}}}</code>}}{{#if: {{{alias3|}}} |<br/><code>{{{alias3}}}</code>}}
| {{#if: {{{desc|}}} | {{{desc}}} | no description }}
'''Default:'''
<code>{{{def}}}</code>

'''Example:'''
{{#if:{{{example|}}}|{{{example}}}
{{#ifeq:{{WsBool|{{{autoPre}}}}}|1|{{#tag:pre|{{{example}}}}}}}| no example }}
| {{{type}}}
| {{#ifeq: {{{status}}}|Deprecated|<span style="color:red">Deprecated</span>|{{{status}}}}}
|-</includeonly>

Template:TemplateData/entry/doc

2020-08-15T14:33:21Z

Streetclaw: Created page with "Template for creating a unified parameter format for templates == About == Creates a list that displays Template parameter in a unified format. This template creates a single..."

Template for creating a unified parameter format for templates

== About ==
Creates a list that displays Template parameter in a unified format.
This template creates a single entry for the Required template [[Template:TemplateData]].

== Parameter ==
{{TemplateData|
{{TemplateData/entry|name=Parameter title|param=name|desc=Specify a title for a parameter of the template documentation|def=NULL|type=String|status=Required}}
{{TemplateData/entry|name=Parameter name|param=param|desc=Specify a name for a parameter of the template documentation|def=NULL|type=String|status=Required}}
{{TemplateData/entry|name=Parameter alias1|param=alias1|desc=Specify a alias for a parameter of the template documentation|def=NULL|type=String|status=Optional}}
{{TemplateData/entry|name=Parameter alias2|param=alias2|desc=Specify a alias for a parameter of the template documentation|def=NULL|type=String|status=Optional}}
{{TemplateData/entry|name=Parameter alias3|param=alias3|desc=Specify a alias for a parameter of the template documentation|def=NULL|type=String|status=Optional}}
{{TemplateData/entry|name=Parameter Description|param=desc|desc=Specify a description for a parameter of the template documentation|def=no description|type=WikiCode|status=Recommended}}
{{TemplateData/entry|name=Parameter Example|param=example|desc=Specify an example for a parameter of the template documentation|def=no example|type=WikiCode|status=Recommended}}
{{TemplateData/entry|name=Parameter type|param=type|desc=Specify a type for a parameter of the template documentation: [[#Data_Dictionary_Notation_.28DDN.29_for_types|Data Dictionary Notation]]|def=NULL|type=[[#Data_Dictionary_Notation_.28DDN.29_for_types|DDNCode]]|status=Required}}
{{TemplateData/entry|name=Parameter status|param=status|desc=Specify a status for a parameter of the template documentation|def=NULL|type=<nowiki>["Required" | "Recommended" | "Optional" | "Deprecated" ]</nowiki>|status=Required}}
{{TemplateData/entry|name=Auto pre|param=autoPre|desc=Automatic pre for examples|def=0|type=Boolean|status=Optional}}
}}

== Examples ==

'''Complete example:'''

{{TemplateData|
{{TemplateData/entry|name=Example name|alias1=Example alias 1|alias2=Example alias 2|alias3=Example alias 3|param=example param|desc=example description|def=NULL|example=xyz|type=String|status=Required}}
{{TemplateData/entry|name=Auto pre name B|alias1=B alias 1|alias2=B alias 2|alias3=B alias 3|param=B param|desc=B description|def=NULL|example=
* List example with containing templates and HTML tags
* No Icon (<code>1</code>): {{ItemLink|Ginger Tom. Salad|noIcon=1}}
* Icon (<code>0</code>): {{ItemLink|Ginger Tom. Salad|noIcon=0}}
* Default (parameter not used / <code>0</code>): {{ItemLink|Ginger Tom. Salad}}
|type=String|status=Required|autoPre=1}}
{{TemplateData/entry|name=Deprecated Example name|alias1=Deprecated alias 1|alias2=Deprecated alias 2|alias3=Deprecated alias 3|param=deprecated param|desc=deprecated description|def=NULL|example=xyz|type=String|status=Deprecated}}
}}

<pre>
{{TemplateData|
{{TemplateData/entry|name=Example name|alias1=Example alias 1|alias2=Example alias 2|alias3=Example alias 3|param=example param|desc=example description|def=NULL|example=xyz|type=String|status=Required}}
{{TemplateData/entry|name=Auto pre name B|alias1=B alias 1|alias2=B alias 2|alias3=B alias 3|param=B param|desc=B description|def=NULL|example=
* List example with containing templates and HTML tags
* No Icon (<code>1</code>): {{ItemLink|Ginger Tom. Salad|noIcon=1}}
* Icon (<code>0</code>): {{ItemLink|Ginger Tom. Salad|noIcon=0}}
* Default (parameter not used / <code>0</code>): {{ItemLink|Ginger Tom. Salad}}
|type=String|status=Required|autoPre=1}}
{{TemplateData/entry|name=Deprecated Example name|alias1=Deprecated alias 1|alias2=Deprecated alias 2|alias3=Deprecated alias 3|param=deprecated param|desc=deprecated description|def=NULL|example=xyz|type=String|status=Deprecated}}
}}
</pre>

== Data Dictionary Notation (DDN) for types ==

The [http://users.csc.calpoly.edu/~jdalbey/SWE/DDnotation.html Data Dictionary Notation (DDN)] is a modified modified [https://en.wikipedia.org/wiki/Backus%E2%80%93Naur_form BNF notation] (which is used in [https://en.wikipedia.org/wiki/Data_dictionary Data Dictionaries]) to describes the structure of data entries. The BNF and DDN notation is used in the field of [https://en.wikipedia.org/wiki/Software_engineering Software engineering (SWE)]. In this case it describes how types have to be structured.

The used DDN Notation is slightly different than the linked DDN Notation:
* The upper limit is '''not''' superscript
* Can have a lower limit
* Can have optional parts

{| class="wikitable"
|-
! Type
! Notation
! Description
|-
| Sequence
| +
| Sequence of definitions
|-
| Alternative
| <nowiki>[...|...]</nowiki>
| Only one element out of this list
|-
| Repetition
| {...}
| Repetition of the definition
|-
| Repetition
| 2 {...}
| Repetition of the definition with the minimum of two
|-
| Repetition
| {...} 5
| Repetition of the definition with the maximum of five
|-
| Repetition
| 1 {...} 6
| Repetition of the definition with the minimum of one and the maximum of six
|-
| Option
| (...)
| Optional definition
|-
| Specific value
| "..."
| fix definition
|}

=== Predefined ===

All predefined Types can be used directly or inside DDNCode

{| class="wikitable"
|-
! Type
! Definition
! Comment
|-
| NULL
| <nowiki>""</nowiki>
| Empty
|-
| NonzeroDigit
| <nowiki>["1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"]</nowiki>
| Single character, 1 - 9
|-
| Digit
| <nowiki>["0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"]</nowiki>
| Single character, 0 - 9
|-
| LowerAlphabet
| <nowiki>["a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z" ]</nowiki>
| Single character, a - z
|-
| UpperAlphabet
| <nowiki>["A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z"]</nowiki>
| Single character, A - Z
|-
| Alphabet
| <nowiki>[LowerAlphabet | UpperAlphabet]</nowiki>
| Single character, a - z / A - Z
|-
| Ascii
| <nowiki>1 {Ascii} 1</nowiki>
| [https://en.wikipedia.org/wiki/ASCII ASCII] character
|-
| Char
| <nowiki>1 {Char} 1</nowiki>
| [https://en.wikipedia.org/wiki/UTF-8 UTF-8] character
|-
| String
| <nowiki>1 {Char}</nowiki>
| One or more UTF-8 characters
|-
| AsciiString
| <nowiki>1 {Ascii}</nowiki>
| One or more ASCII characters
|-
| WikiCode
| <nowiki>1 {WikiCode} 1</nowiki>
| Any wiki code
|-
| DDNCode
| <nowiki>1 {DDNCode} 1</nowiki>
| Any DDNCode (links are allowed)
|-
| Number
| <nowiki>1 {Digit}</nowiki>
| Any natural number with zero
|-
| Decimal
| <nowiki>1 {Digit} + ( "." + 1 {Digit} )</nowiki>
| Any natural number with zero
|-
| NonzeroNumber
| <nowiki>[ 1 {NonzeroDigit} 1 | 2 {Digit} ]</nowiki>
| Any natural number without zero
|-
| SignedNumber
| <nowiki>[ "-" + 1 {NonzeroDigit} 1 | 1 {Digit} 1 | ("-") + 2 {Digit} ]</nowiki>
| Any Integer (doesn't allow -0 only 0)
|-
| PercentValue
| <nowiki>[ 1 {Digit} 2 | "100" ]</nowiki>
| Any natural number from 0 to 100
|-
| SignedPercentValue
| <nowiki>[ "-" + 1 {NonzeroDigit} 1 | 1 {Digit} 1 | ("-") + 2 {Digit} 2 | ("-") + "100" ]</nowiki>
| Any natural number from 0 to 100 and from -1 to -100
|-
| Percent
| <nowiki>PercentValue + "%"</nowiki>
| From 0% to 100% (natural number)
|-
| SignedPercent
| <nowiki>SignedPercentValue + "%"</nowiki>
| From 0% to 100% and from -1% to -100% (natural number)
|-
| Boolean
| <nowiki>["0" | "1"]</nowiki>
| 0 (off) or 1 (on)
|-
| True
| <nowiki>"1"</nowiki>
| 1 (on)
|-
| False
| <nowiki>"0"</nowiki>
| 0 (off)
|-
| Month
| <nowiki>[ 1 {NonzeroDigit} 1 | "10" | "11" | "12"]</nowiki>
| 1 - 12
|-
| Monthfill
| <nowiki>["0" + 1 {NonzeroDigit} 1 | "10" | "11" | "12"]</nowiki>
| 01, 02, 03 ... - 12
|-
| Monthname
| <nowiki>["January" | "February" | "March" | "April" | "May" | "June" | "July" | "August" | "September" | "October" | "November" | "December"]</nowiki>
| Month (name)
|-
| Day
| <nowiki>[ ( [ "1" | "2" ] ) + 1 {Digit} 1 | "30" | "31" ]</nowiki>
| 1 - 31
|-
| Dayfill
| <nowiki>[ [ "0" | 1" | "2" ] + 1 {Digit} 1 | "30" | "31" ]</nowiki>
| 01, 02, 03 ... - 31
|-
| Year
| <nowiki>1 {Digit}</nowiki>
| Any year
|-
| LabeledYear
| <nowiki>Year + [" AD" | " BC" | " AC"]</nowiki>
| Any year with label
|-
| LevelNumber
| <nowiki>[ 1 {NonzeroDigit} 1 | 2 {Digit} 2 ]</nowiki>
| 1, 2, ... - 99
|-
| LevelNumberFill
| <nowiki>[ "0" + 1 {NonzeroDigit} 1 | 2 {Digit} 2 ]</nowiki>
| 01, 02, ... - 99
|}

=== Special Predefined ===

These predefines are based on the current Template

{| class="wikitable"
|-
! Type
! Definition
! Comment
|-
| <nowiki><name></nowiki>
| <nowiki>"{{{<name>}}}"</nowiki>
| All parameter names of the current template (this means: use the same type as in <nowiki><name></nowiki>)
|-
| <nowiki><Template:<name>></nowiki>
| <nowiki>"[[Template:<name>]]"</nowiki>
| Other templates (link required for type; this means: use these template as type; used in nested templates)
|}

=== Examples ===
* String + Number + {param}
* Number + param
(param is in this example an other parameter of the template)
* String + " = " + 1 {String} 2
* String + (Number)

Template:Doc

2020-08-15T14:31:16Z

Streetclaw:

<noinclude>{{doc}}</noinclude><includeonly>{{/doc}}
[[Category:Documented template]]</includeonly>

Template:Doc/doc

2020-08-15T14:28:32Z

Streetclaw: Created page with "Template documentation"

Template documentation

Template:Doc

2020-08-15T14:28:18Z

Streetclaw: Created page with "<noinclude>{{doc}}</noinclude><includeonly>{{/doc}}</includeonly>"

MediaWiki:Home-description/de

2020-08-11T13:23:59Z

Streetclaw:

Startseite

MediaWiki:Home-description/de

2020-08-11T13:22:56Z

Streetclaw: Created page with "Hauptseite"

Hauptseite

MediaWiki:Sidebar

2020-08-11T13:19:02Z

Streetclaw:

MediaWiki:Discord-url

2020-08-11T13:17:52Z

Streetclaw: Created page with "https://c2dl.info/r/md"

https://c2dl.info/r/md

MediaWiki:Reddit-url

2020-08-11T13:17:04Z

Streetclaw: Created page with "https://www.reddit.com/r/CrossCodeModding/"

https://www.reddit.com/r/CrossCodeModding/

MediaWiki:Gitlab-url

2020-08-11T13:16:46Z

Streetclaw: Created page with "https://gitlab.com/CCDirectLink"

https://gitlab.com/CCDirectLink

MediaWiki:Github-url

2020-08-11T13:16:29Z

Streetclaw: Created page with "https://github.com/CCDirectLink"

https://github.com/CCDirectLink

MediaWiki:Gitlab-description

2020-08-11T13:15:46Z

Streetclaw: Created page with "GitLab"

GitLab

MediaWiki:Github-description

2020-08-11T13:15:33Z

Streetclaw: Created page with "GitHub"

GitHub

MediaWiki:Reddit-description

2020-08-11T13:15:20Z

Streetclaw: Created page with "Reddit"

MediaWiki:Discord-description

2020-08-11T13:14:55Z

Streetclaw: Created page with "Discord"

Discord

MediaWiki:Home-description

2020-08-11T13:13:14Z

Streetclaw:

Home

MediaWiki:Sidebar

2020-08-11T13:12:38Z

Streetclaw:

MediaWiki:C2dl-nav

2020-08-11T13:11:57Z

Streetclaw: Created page with "C2DL"

C2DL