used-exports.php

<?php
array (
  'Contribute.Component' => 
  array (
    'comment' => '## Component
\\Fresh\\Component is the base class. It holds the views, a handler, and other settings that need to be global. It also processes form submissions before passing to your `submit` handler.',
    'key' => 'Contribute.Component',
    'exportline' => '@export(Contribute.Component)',
  ),
  'Feature.uploadFile' => 
  array (
    'comment' => '## Uploading files
To enable automatic file uploads, call `$component->setUpload($storageDir, $urlPrefix)`. You are responsible for routing that file.  
The `$urlPrefix` is used to prepend the file-url when passing formdata to your `submit` handler',
    'key' => 'Feature.uploadFile',
    'exportline' => '@export(Feature.uploadFile)',
  ),
  'Feature.submission' => 
  array (
    'comment' => '## Submitting data sort of automaticallyish
You must still set a `submit` handler like so:
```php
$myDbObj = get_my_db_instance();
$compo->setSubmitHandler(
    function (string $tableName, array $dataToSave, $itemId) use ($myDbObj){
        $myDbObj->save($tableName,$dataToSave,$itemId);
    }
);
```',
    'key' => 'Feature.submission',
    'exportline' => '@export(Feature.submission)',
  ),
  'Feature.setup' => 
  array (
    'comment' => '## Routing, Setting things up
Use the setup step to do routing, basically. This requires you to append setup code to views. Here\'s a simple (bad) example:
```php
$phpCode = \'<?php if ($url==\'/\')echo $this; ?>`
/`$this` refers to the view which is being setup.
$view = $compo->view("Page_Home"); //this points to $compoDir/view/Page_HomeView.php
$view->appendSetupCode($phpCode);
```
This setup code must be appended pre-compile or inside a compile handler.

Then to execute your setup:
```php
$compo = new \\Fresh\\Component($name,$componentDir);
$forceRecompilation = true;// good when developing. Bad for production.
$compo->compile($forceRecompilation); //  Defaults to false, if you don\'t pass a paramater
$passthru = [\'url\'=> cleanMyUrl( $_SERVER[\'REQUEST_URI\'] ) ];
$compo->setup($passthru);
```
All your `setup` code will be run, in no particular order, and your `Page_Home` view will be displayed when `yoursite.atld/` is requested',
    'key' => 'Feature.setup',
    'exportline' => '@export(Feature.setup)',
  ),
  'Feature.compile' => 
  array (
    'comment' => '## Compiling
Call `$compo->compile(true)` to force re-compilation of all views & forms. Call `$compo->compile()` to use the default `$forceRecompile` value of `false` to only compile views that have changed.  
You should use `true` in development probably.  
I\'ve had troubles with conditional recompiling (passing `false`) on my localhost, and I think it was because of file permissions issues, but I\'m not sure.

And you can set a host of your own `compile` handlers.',
    'key' => 'Feature.compile',
    'exportline' => '@export(Feature.compile)',
  ),
  'Extend.runtimeHandler' => 
  array (
    'comment' => '## Runtime Handlers
Use `$compo->setRuntimeHandler(...)` or `$compo->addRuntimeHandler($handlerName,$function)`. What the handler receives varies greatly.  
`setRuntimeHandler` will only allow one handler per `$name` & the callback\'s value will be returned when the runtime handler is called.
`addRuntimeHandler` will allow multiple handlers. When the named handler is called, each callback\'s value will be stored in an array & that array will be returned.

### Noteable runtime handlers:
- `find`: `function($table, $findProperty){return $anArrayOfObjects};`
   - This MUST be declared to use the entity features
- `format_formatterName`: `function($value){return convertToMyFormat($value);}`
   - `$compo->setRuntimeHandler(\'runtime\',\'format_\'.$formatterName,$callback);`
   - or `$compo->view($view)->addFormatter($name,$callback)`
- `addResources`: `function($viewObj, $resourcesList){...use your framework or whatever...}',
    'key' => 'Extend.runtimeHandler',
    'exportline' => '@export(Extend.runtimeHandler)',
  ),
  'Extend.compileHandler' => 
  array (
    'comment' => '## Compile Handlers
These will be run during the compile step.

NEED TO REDO THIS DOC FOR COMPILE HANDLERS

Use `$compo->addCompileHandler($handlerName,$function)`. What the handler receives varies greatly.  

### Noteable Compile handlers: (name: Callable example)
- `preDoc`: `function($cleanSource,$viewContent,$compiler,$view){ return str_replace(\'<bad-tag\', \'<good-tag\',$cleanSource); }`
   - This runs before the RBDoc (DOMDocument) instance is created
   - Generally, you should return a modified version of the $cleanSource
   - $cleanSource is the view\'s source code with the PHP extracted by $compiler
   - $viewContent is the view\'s source code, with inline PHP still in tact
   - $compiler is an instance of \\RBDoc\\Compiler, which extracted the php
   - $view is an instance of the view object
- `form`: `function($formViewObj,$doc,$compiler,$formNode){$formNode->setAttribute(\'action\',\'/some/url/\');}`
   - Return values are discarded, but you can modify the objects.
   - I\'m not sure, but some things might be overwritten by this library, such as the `action` or `method` attributes on the node.
   - $formViewObj is an instance of \\Fresh\\Form
   - $doc is \\RBDoc instance
   - $compiler is an \\RBDoc\\Compiler
   - $formNode is an \\RBDoc\\Node (DOMElement) instance, who\'s tag is `<form ...>`',
    'key' => 'Extend.compileHandler',
    'exportline' => '@export(Extend.compileHandler)',
  ),
  'Feature.viewQueries' => 
  array (
    'comment' => '### View Queries: A compile handler
In [my Liaison Package](https://github.com/Taeluf/Liaison-FreshCompo), I use this for routing. Here\'s a simplified version.
```php
$compo->addViewQuery(\'//lia-route\', //runs on every `<lia-route` tag
    function($rbDoc, $view, $compiler, $node){
        $route = $node->getAttribute(\'pattern\');
        $escRoute = var_export($route, true); // because `$route` is only available during this compile step. 
        $phpCode = \'<?php if ($url==$escRoute)echo $this; ?>`
        $view->appendSetupCode($phpCode);
    }
);
```
This function will be run during the `compile` step for each `<lia-route` tag your view contains. No errors if not found.  
It will append setup code that does routing.  
Then when you call `$compo->setup[\'url\'=>$theUrl]`, the setup code will run and your view will be displayed if the route matches the url.',
    'key' => 'Feature.viewQueries',
    'exportline' => '@export(Feature.viewQueries)',
  ),
)
?>